1773 lines
46 KiB
C++
1773 lines
46 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#include "stdafx.h"
|
|
#include "GameConfig.h"
|
|
#include "GlobalFunctions.h"
|
|
#include "History.h"
|
|
#include "MainFrm.h"
|
|
#include "MapCheckDlg.h"
|
|
#include "MapDoc.h"
|
|
#include "MapEntity.h"
|
|
#include "MapSolid.h"
|
|
#include "MapWorld.h"
|
|
#include "Options.h"
|
|
#include "ToolManager.h"
|
|
#include "VisGroup.h"
|
|
#include "hammer.h"
|
|
#include "MapOverlay.h"
|
|
#include "Selection.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
|
|
// ********
|
|
// NOTE: Make sure the order matches g_MapErrorStringIDs below!
|
|
// ********
|
|
typedef enum
|
|
{
|
|
ErrorNoPlayerStart,
|
|
ErrorMixedFace,
|
|
ErrorDuplicatePlanes,
|
|
ErrorMissingTarget,
|
|
ErrorInvalidTexture,
|
|
ErrorSolidStructure,
|
|
ErrorUnusedKeyvalues,
|
|
ErrorEmptyEntity,
|
|
ErrorDuplicateKeys,
|
|
ErrorSolidContents,
|
|
ErrorInvalidTextureAxes,
|
|
ErrorDuplicateFaceIDs,
|
|
ErrorDuplicateNodeIDs,
|
|
ErrorBadConnections,
|
|
ErrorHiddenGroupHiddenChildren,
|
|
ErrorHiddenGroupVisibleChildren,
|
|
ErrorHiddenGroupMixedChildren,
|
|
ErrorHiddenObjectNoVisGroup,
|
|
ErrorHiddenChildOfEntity,
|
|
ErrorIllegallyHiddenObject,
|
|
ErrorKillInputRaceCondition,
|
|
ErrorOverlayFaceList,
|
|
} MapErrorType;
|
|
|
|
// ********
|
|
// NOTE: Make sure the order matches MapErrorType above!
|
|
// ********
|
|
struct
|
|
{
|
|
int m_StrResourceID;
|
|
int m_DescriptionResourceID;
|
|
} g_MapErrorStrings[] =
|
|
{
|
|
{IDS_NOPLAYERSTART, IDS_NOPLAYERSTART_DESC},
|
|
{IDS_MIXEDFACES, IDS_MIXEDFACES_DESC},
|
|
{IDS_DUPLICATEPLANES, IDS_DUPLICATEPLANES_DESC},
|
|
{IDS_UNMATCHEDTARGET, IDS_UNMATCHEDTARGET_DESC},
|
|
{IDS_INVALIDTEXTURE, IDS_INVALIDTEXTURE_DESC},
|
|
{IDS_SOLIDSTRUCTURE, IDS_SOLIDSTRUCTURE_DESC},
|
|
{IDS_UNUSEDKEYVALUES, IDS_UNUSEDKEYVALUES_DESC},
|
|
{IDS_EMPTYENTITY, IDS_EMPTYENTITY_DESC},
|
|
{IDS_DUPLICATEKEYS, IDS_DUPLICATEKEYS_DESC},
|
|
{IDS_SOLIDCONTENT, IDS_SOLIDCONTENT_DESC},
|
|
{IDS_INVALIDTEXTUREAXES, IDS_INVALIDTEXTUREAXES_DESC},
|
|
{IDS_DUPLICATEFACEID, IDS_DUPLICATEFACEID_DESC},
|
|
{IDS_DUPLICATE_NODE_ID, IDS_DUPLICATE_NODE_ID_DESC},
|
|
{IDS_BAD_CONNECTIONS, IDS_BAD_CONNECTIONS_DESC},
|
|
{IDS_HIDDEN_GROUP_HIDDEN_CHILDREN, IDS_HIDDEN_GROUP_HIDDEN_CHILDREN_DESC},
|
|
{IDS_HIDDEN_GROUP_VISIBLE_CHILDREN, IDS_HIDDEN_GROUP_VISIBLE_CHILDREN_DESC},
|
|
{IDS_HIDDEN_GROUP_MIXED_CHILDREN, IDS_HIDDEN_GROUP_MIXED_CHILDREN_DESC},
|
|
{IDS_HIDDEN_NO_VISGROUP, IDS_HIDDEN_NO_VISGROUP_DESC},
|
|
{IDS_HIDDEN_CHILD_OF_ENTITY, IDS_HIDDEN_CHILD_OF_ENTITY_DESC},
|
|
{IDS_HIDDEN_ILLEGALLY, IDS_HIDDEN_ILLEGALLY_DESC},
|
|
{IDS_KILL_INPUT_RACE_CONDITION, IDS_KILL_INPUT_RACE_CONDITION_DESC},
|
|
{IDS_BAD_OVERLAY, IDS_DAB_OVERLAY_DESC}
|
|
};
|
|
|
|
|
|
|
|
typedef enum
|
|
{
|
|
CantFix,
|
|
NeedsFix,
|
|
Fixed,
|
|
} FIXCODE;
|
|
|
|
|
|
struct MapError
|
|
{
|
|
CMapClass *pObjects[3];
|
|
MapErrorType Type;
|
|
DWORD dwExtra;
|
|
FIXCODE Fix;
|
|
};
|
|
|
|
|
|
//
|
|
// Fix functions.
|
|
//
|
|
static void FixDuplicatePlanes(MapError *pError);
|
|
static void FixSolidStructure(MapError *pError);
|
|
static void FixInvalidTexture(MapError *pError);
|
|
static void FixInvalidTextureAxes(MapError *pError);
|
|
static void FixUnusedKeyvalues(MapError *pError);
|
|
static void FixEmptyEntity(MapError *pError);
|
|
static void FixBadConnections(MapError *pError);
|
|
static void FixInvalidContents(MapError *pError);
|
|
static void FixDuplicateFaceIDs(MapError *pError);
|
|
static void FixDuplicateNodeIDs(MapError *pError);
|
|
static void FixMissingTarget(MapError *pError);
|
|
void FixHiddenObject(MapError *pError);
|
|
static void FixKillInputRaceCondition(MapError *pError);
|
|
static void FixOverlayFaceList(MapError *pError);
|
|
|
|
|
|
CMapCheckDlg *s_pDlg = NULL;
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CMapCheckDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CMapCheckDlg)
|
|
ON_BN_CLICKED(IDC_GO, OnGo)
|
|
ON_LBN_SELCHANGE(IDC_ERRORS, OnSelchangeErrors)
|
|
ON_LBN_DBLCLK(IDC_ERRORS, OnDblClkErrors)
|
|
ON_WM_PAINT()
|
|
ON_BN_CLICKED(IDC_FIX, OnFix)
|
|
ON_BN_CLICKED(IDC_FIXALL, OnFixall)
|
|
ON_WM_DESTROY()
|
|
ON_WM_CLOSE()
|
|
ON_BN_CLICKED(IDC_CHECK_VISIBLE_ONLY, OnCheckVisibleOnly)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Visibility check
|
|
//-----------------------------------------------------------------------------
|
|
inline bool IsCheckVisible( CMapClass *pClass )
|
|
{
|
|
return (Options.general.bCheckVisibleMapErrors == FALSE) || pClass->IsVisible();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::CheckForProblems(CWnd *pwndParent)
|
|
{
|
|
if (!s_pDlg)
|
|
{
|
|
s_pDlg = new CMapCheckDlg;
|
|
s_pDlg->Create(IDD, pwndParent);
|
|
}
|
|
|
|
if (!s_pDlg->DoCheck())
|
|
{
|
|
// Found problems.
|
|
s_pDlg->ShowWindow(SW_SHOW);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pParent -
|
|
//-----------------------------------------------------------------------------
|
|
CMapCheckDlg::CMapCheckDlg(CWnd *pParent)
|
|
: CDialog(CMapCheckDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CMapCheckDlg)
|
|
m_bCheckVisible = FALSE;
|
|
//}}AFX_DATA_INIT
|
|
|
|
m_bCheckVisible = Options.general.bCheckVisibleMapErrors;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pDX -
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
|
|
//{{AFX_DATA_MAP(CMapCheckDlg)
|
|
DDX_Control(pDX, IDC_FIXALL, m_cFixAll);
|
|
DDX_Control(pDX, IDC_FIX, m_Fix);
|
|
DDX_Control(pDX, IDC_GO, m_Go);
|
|
DDX_Control(pDX, IDC_DESCRIPTION, m_Description);
|
|
DDX_Control(pDX, IDC_ERRORS, m_Errors);
|
|
DDX_Check(pDX, IDC_CHECK_VISIBLE_ONLY, m_bCheckVisible);
|
|
//}}AFX_DATA_MAP
|
|
|
|
if ( pDX->m_bSaveAndValidate )
|
|
{
|
|
Options.general.bCheckVisibleMapErrors = m_bCheckVisible;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Checkbox indicating whether we should check visible errors
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::OnCheckVisibleOnly()
|
|
{
|
|
UpdateData( TRUE );
|
|
DoCheck();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Selects the current error objects and centers the views on it.
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::OnGo()
|
|
{
|
|
GotoSelectedErrors();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::GotoSelectedErrors()
|
|
{
|
|
int iSel = m_Errors.GetCurSel();
|
|
if (iSel == LB_ERR)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ToolManager()->SetTool(TOOL_POINTER);
|
|
|
|
CMapObjectList Objects;
|
|
for (int i = 0; i < m_Errors.GetCount(); i++)
|
|
{
|
|
if (m_Errors.GetSel(i) > 0)
|
|
{
|
|
MapError *pError = (MapError *)m_Errors.GetItemDataPtr(i);
|
|
if (pError)
|
|
{
|
|
Objects.AddToTail(pError->pObjects[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
|
|
pDoc->SelectObjectList(&Objects);
|
|
pDoc->CenterViewsOnSelection();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Fixes all the selected errors.
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::OnFix()
|
|
{
|
|
int iSel = m_Errors.GetCurSel();
|
|
if (iSel == LB_ERR)
|
|
{
|
|
return;
|
|
}
|
|
|
|
UpdateBox ub;
|
|
CMapObjectList Objects;
|
|
ub.Objects = &Objects;
|
|
|
|
for (int i = 0; i < m_Errors.GetCount(); i++)
|
|
{
|
|
if (m_Errors.GetSel(i) > 0)
|
|
{
|
|
MapError *pError = (MapError *)m_Errors.GetItemDataPtr(i);
|
|
if (pError)
|
|
{
|
|
Fix(pError, ub);
|
|
}
|
|
}
|
|
}
|
|
|
|
OnSelchangeErrors();
|
|
CMapDoc::GetActiveMapDoc()->UpdateAllViews( MAPVIEW_UPDATE_OBJECTS );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pError -
|
|
// ub -
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::Fix(MapError *pError, UpdateBox &ub)
|
|
{
|
|
CMapDoc::GetActiveMapDoc()->SetModifiedFlag();
|
|
|
|
if (pError->Fix != NeedsFix)
|
|
{
|
|
// should never get here because this button is supposed
|
|
// to be disabled if the error cannot be fixed
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Expand the bounds of the update region to include the broken objects.
|
|
//
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
if (!pError->pObjects[i])
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ub.Objects->AddToTail(pError->pObjects[i]);
|
|
|
|
Vector mins;
|
|
Vector maxs;
|
|
pError->pObjects[i]->GetRender2DBox(mins, maxs);
|
|
ub.Box.UpdateBounds(mins, maxs);
|
|
}
|
|
|
|
//
|
|
// Perform the fix.
|
|
//
|
|
switch (pError->Type)
|
|
{
|
|
case ErrorDuplicatePlanes:
|
|
{
|
|
FixDuplicatePlanes(pError);
|
|
break;
|
|
}
|
|
case ErrorDuplicateFaceIDs:
|
|
{
|
|
FixDuplicatePlanes(pError);
|
|
break;
|
|
}
|
|
case ErrorDuplicateNodeIDs:
|
|
{
|
|
FixDuplicateNodeIDs(pError);
|
|
break;
|
|
}
|
|
case ErrorMissingTarget:
|
|
{
|
|
FixMissingTarget(pError);
|
|
break;
|
|
}
|
|
case ErrorSolidStructure:
|
|
{
|
|
FixSolidStructure(pError);
|
|
break;
|
|
}
|
|
case ErrorSolidContents:
|
|
{
|
|
FixInvalidContents(pError);
|
|
break;
|
|
}
|
|
case ErrorInvalidTexture:
|
|
{
|
|
FixInvalidTexture(pError);
|
|
break;
|
|
}
|
|
case ErrorInvalidTextureAxes:
|
|
{
|
|
FixInvalidTextureAxes(pError);
|
|
break;
|
|
}
|
|
case ErrorUnusedKeyvalues:
|
|
{
|
|
FixUnusedKeyvalues(pError);
|
|
break;
|
|
}
|
|
case ErrorBadConnections:
|
|
{
|
|
FixBadConnections(pError);
|
|
break;
|
|
}
|
|
case ErrorEmptyEntity:
|
|
{
|
|
FixEmptyEntity(pError);
|
|
break;
|
|
}
|
|
case ErrorHiddenGroupVisibleChildren:
|
|
case ErrorHiddenGroupMixedChildren:
|
|
case ErrorHiddenGroupHiddenChildren:
|
|
case ErrorHiddenObjectNoVisGroup:
|
|
case ErrorHiddenChildOfEntity:
|
|
case ErrorIllegallyHiddenObject:
|
|
{
|
|
FixHiddenObject(pError);
|
|
break;
|
|
}
|
|
case ErrorKillInputRaceCondition:
|
|
{
|
|
FixKillInputRaceCondition(pError);
|
|
break;
|
|
}
|
|
case ErrorOverlayFaceList:
|
|
{
|
|
FixOverlayFaceList( pError );
|
|
break;
|
|
}
|
|
}
|
|
|
|
pError->Fix = Fixed;
|
|
|
|
//
|
|
// Expand the bounds of the update region to include the fixed objects.
|
|
//
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
if (!pError->pObjects[i])
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Vector mins;
|
|
Vector maxs;
|
|
pError->pObjects[i]->GetRender2DBox(mins, maxs);
|
|
ub.Box.UpdateBounds(mins, maxs);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::OnFixall()
|
|
{
|
|
int iSel = m_Errors.GetCurSel();
|
|
if (iSel == LB_ERR)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MapError *pError = (MapError *) m_Errors.GetItemDataPtr(iSel);
|
|
|
|
if (pError->Fix == CantFix)
|
|
{
|
|
// should never get here because this button is supposed
|
|
// to be disabled if the error cannot be fixed
|
|
return;
|
|
}
|
|
|
|
UpdateBox ub;
|
|
CMapObjectList Objects;
|
|
ub.Objects = &Objects;
|
|
|
|
// For every selected error...
|
|
for (int i = 0; i < m_Errors.GetCount(); i++)
|
|
{
|
|
if (m_Errors.GetSel(i) > 0)
|
|
{
|
|
pError = (MapError *)m_Errors.GetItemDataPtr(i);
|
|
if ((pError) && (pError->Fix == NeedsFix))
|
|
{
|
|
// Find and fix every error of the same type.
|
|
for (int j = 0; j < m_Errors.GetCount(); j++)
|
|
{
|
|
MapError *pError2 = (MapError *)m_Errors.GetItemDataPtr(j);
|
|
if ((pError2->Type != pError->Type) || (pError2->Fix != NeedsFix))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Fix(pError2, ub);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
OnSelchangeErrors();
|
|
CMapDoc::GetActiveMapDoc()->UpdateAllViews( MAPVIEW_UPDATE_OBJECTS );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::OnSelchangeErrors()
|
|
{
|
|
// change description to match error
|
|
int iSel = m_Errors.GetCurSel();
|
|
|
|
if(iSel == LB_ERR)
|
|
{
|
|
m_Fix.EnableWindow(FALSE);
|
|
m_cFixAll.EnableWindow(FALSE);
|
|
m_Go.EnableWindow(FALSE);
|
|
}
|
|
|
|
CString str;
|
|
MapError *pError;
|
|
pError = (MapError*) m_Errors.GetItemDataPtr(iSel);
|
|
|
|
// Figure out which error string we're using.
|
|
int iErrorStr = (int)pError->Type;
|
|
iErrorStr = clamp( iErrorStr, 0, ARRAYSIZE( g_MapErrorStrings ) - 1 );
|
|
Assert( iErrorStr == (int)pError->Type );
|
|
|
|
str.LoadString(g_MapErrorStrings[iErrorStr].m_DescriptionResourceID);
|
|
m_Description.SetWindowText(str);
|
|
|
|
m_Go.EnableWindow(pError->pObjects[0] != NULL);
|
|
|
|
// set state of fix button
|
|
m_Fix.EnableWindow(pError->Fix == NeedsFix);
|
|
m_cFixAll.EnableWindow(pError->Fix != CantFix);
|
|
|
|
// set text of fix button
|
|
switch (pError->Fix)
|
|
{
|
|
case NeedsFix:
|
|
m_Fix.SetWindowText("&Fix");
|
|
break;
|
|
case CantFix:
|
|
m_Fix.SetWindowText("Can't fix");
|
|
break;
|
|
case Fixed:
|
|
m_Fix.SetWindowText("(fixed)");
|
|
break;
|
|
}
|
|
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
|
|
pDoc->GetSelection()->SetMode(selectObjects);
|
|
|
|
if (pError->pObjects[0])
|
|
{
|
|
pDoc->SelectObject(pError->pObjects[0], scClear|scSelect|scSaveChanges );
|
|
}
|
|
else
|
|
{
|
|
pDoc->SelectObject(NULL, scClear|scSaveChanges );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::OnDblClkErrors()
|
|
{
|
|
GotoSelectedErrors();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::OnPaint()
|
|
{
|
|
CPaintDC dc(this); // device context for painting
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::KillErrorList()
|
|
{
|
|
// delete items in list.. their data ptrs are allocated objects
|
|
int iSize = m_Errors.GetCount();
|
|
for(int i = 0; i < iSize; i++)
|
|
{
|
|
MapError *pError = (MapError*) m_Errors.GetItemDataPtr(i);
|
|
delete pError;
|
|
}
|
|
|
|
m_Errors.ResetContent();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Builds the listbox string for the given error and adds it to the list.
|
|
//-----------------------------------------------------------------------------
|
|
static void AddErrorToListBox(CListBox *pList, MapError *pError)
|
|
{
|
|
CString str;
|
|
|
|
// Figure out which error string we're using.
|
|
int iErrorStr = (int)pError->Type;
|
|
iErrorStr = clamp( iErrorStr, 0, ARRAYSIZE( g_MapErrorStrings ) - 1 );
|
|
Assert( iErrorStr == (int)pError->Type );
|
|
|
|
str.LoadString(g_MapErrorStrings[iErrorStr].m_StrResourceID);
|
|
|
|
if (str.Find('%') != -1)
|
|
{
|
|
if (pError->Type == ErrorUnusedKeyvalues)
|
|
{
|
|
// dwExtra has the name of the string in it
|
|
CString str2 = str;
|
|
CMapEntity *pEntity = (CMapEntity *)pError->pObjects[0];
|
|
str.Format(str2, pEntity->GetClassName(), pError->dwExtra);
|
|
}
|
|
else
|
|
{
|
|
CString str2 = str;
|
|
str.Format(str2, pError->dwExtra);
|
|
}
|
|
}
|
|
|
|
int iIndex = pList->AddString(str);
|
|
pList->SetItemDataPtr(iIndex, (PVOID)pError);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pList -
|
|
// Type -
|
|
// dwExtra -
|
|
// ... -
|
|
//-----------------------------------------------------------------------------
|
|
static void AddError(CListBox *pList, MapErrorType Type, DWORD dwExtra, ...)
|
|
{
|
|
MapError *pError = new MapError;
|
|
memset(pError, 0, sizeof(MapError));
|
|
|
|
pError->Type = Type;
|
|
pError->dwExtra = dwExtra;
|
|
pError->Fix = CantFix;
|
|
|
|
va_list vl;
|
|
va_start(vl, dwExtra);
|
|
|
|
//
|
|
// Get the object pointer from the variable argument list.
|
|
//
|
|
switch (Type)
|
|
{
|
|
case ErrorNoPlayerStart:
|
|
{
|
|
// no objects.
|
|
break;
|
|
}
|
|
|
|
case ErrorMixedFace:
|
|
case ErrorMissingTarget:
|
|
case ErrorDuplicatePlanes:
|
|
case ErrorDuplicateFaceIDs:
|
|
case ErrorDuplicateNodeIDs:
|
|
case ErrorSolidStructure:
|
|
case ErrorSolidContents:
|
|
case ErrorInvalidTexture:
|
|
case ErrorUnusedKeyvalues:
|
|
case ErrorBadConnections:
|
|
case ErrorEmptyEntity:
|
|
case ErrorDuplicateKeys:
|
|
case ErrorInvalidTextureAxes:
|
|
case ErrorHiddenGroupHiddenChildren:
|
|
case ErrorHiddenGroupVisibleChildren:
|
|
case ErrorHiddenGroupMixedChildren:
|
|
case ErrorHiddenObjectNoVisGroup:
|
|
case ErrorHiddenChildOfEntity:
|
|
case ErrorIllegallyHiddenObject:
|
|
case ErrorOverlayFaceList:
|
|
{
|
|
pError->pObjects[0] = va_arg(vl, CMapClass *);
|
|
break;
|
|
}
|
|
|
|
case ErrorKillInputRaceCondition:
|
|
{
|
|
pError->pObjects[0] = va_arg(vl, CMapClass *);
|
|
pError->dwExtra = (DWORD)va_arg(vl, CEntityConnection *);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set the can fix flag.
|
|
//
|
|
switch (Type)
|
|
{
|
|
case ErrorSolidContents:
|
|
case ErrorDuplicatePlanes:
|
|
case ErrorDuplicateFaceIDs:
|
|
case ErrorDuplicateNodeIDs:
|
|
case ErrorSolidStructure:
|
|
case ErrorInvalidTexture:
|
|
case ErrorUnusedKeyvalues:
|
|
case ErrorMissingTarget:
|
|
case ErrorBadConnections:
|
|
case ErrorEmptyEntity:
|
|
case ErrorDuplicateKeys:
|
|
case ErrorInvalidTextureAxes:
|
|
case ErrorHiddenGroupHiddenChildren:
|
|
case ErrorHiddenGroupVisibleChildren:
|
|
case ErrorHiddenGroupMixedChildren:
|
|
case ErrorHiddenObjectNoVisGroup:
|
|
case ErrorHiddenChildOfEntity:
|
|
case ErrorIllegallyHiddenObject:
|
|
case ErrorKillInputRaceCondition:
|
|
case ErrorOverlayFaceList:
|
|
{
|
|
pError->Fix = NeedsFix;
|
|
break;
|
|
}
|
|
}
|
|
|
|
va_end(vl);
|
|
|
|
AddErrorToListBox(pList, pError);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pObject -
|
|
// DWORD -
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL FindPlayer(CMapEntity *pObject, DWORD)
|
|
{
|
|
if ( !IsCheckVisible( pObject ) )
|
|
return TRUE;
|
|
|
|
if (pObject->IsPlaceholder() && pObject->IsClass("info_player_start"))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pList -
|
|
// pWorld -
|
|
//-----------------------------------------------------------------------------
|
|
static void CheckRequirements(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
// ensure there's a player start ..
|
|
if (pWorld->EnumChildren((ENUMMAPCHILDRENPROC)FindPlayer, 0, MAPCLASS_TYPE(CMapEntity)))
|
|
{
|
|
// if rvl is !0, it was not stopped prematurely.. which means there is
|
|
// NO player start.
|
|
AddError(pList, ErrorNoPlayerStart, 0);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pSolid -
|
|
// pList -
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckMixedFaces(CMapSolid *pSolid, CListBox *pList)
|
|
{
|
|
if ( !IsCheckVisible( pSolid ) )
|
|
return TRUE;
|
|
|
|
// run thru faces..
|
|
int iFaces = pSolid->GetFaceCount();
|
|
int iSolid = 2; // start off ambivalent
|
|
int i;
|
|
for(i = 0; i < iFaces; i++)
|
|
{
|
|
CMapFace *pFace = pSolid->GetFace(i);
|
|
|
|
char ch = pFace->texture.texture[0];
|
|
if((ch == '*' && iSolid == 1) || (ch != '*' && iSolid == 0))
|
|
{
|
|
break;
|
|
}
|
|
else iSolid = (ch == '*') ? 0 : 1;
|
|
}
|
|
|
|
if(i == iFaces) // all ok
|
|
return TRUE;
|
|
|
|
// NOT ok
|
|
AddError(pList, ErrorMixedFace, 0, pSolid);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void CheckMixedFaces(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckMixedFaces, (DWORD)pList, MAPCLASS_TYPE(CMapSolid));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns true if there is another node entity in the world with the
|
|
// same node ID as the given entity.
|
|
// Input : pNode -
|
|
// pWorld -
|
|
//-----------------------------------------------------------------------------
|
|
bool FindDuplicateNodeID(CMapEntity *pNode, CMapWorld *pWorld)
|
|
{
|
|
if ( !IsCheckVisible( pNode ) )
|
|
return false;
|
|
|
|
EnumChildrenPos_t pos;
|
|
CMapClass *pChild = pWorld->GetFirstDescendent(pos);
|
|
while (pChild != NULL)
|
|
{
|
|
CMapEntity *pEntity = dynamic_cast<CMapEntity *>(pChild);
|
|
if (pEntity && IsCheckVisible( pEntity ) && (pEntity != pNode) && pEntity->IsNodeClass())
|
|
{
|
|
int nNodeID1 = pNode->GetNodeID();
|
|
int nNodeID2 = pEntity->GetNodeID();
|
|
if ((nNodeID1 != 0) && (nNodeID2 != 0) && (nNodeID1 == nNodeID2))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
pChild = pWorld->GetNextDescendent(pos);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks for node entities with the same node ID.
|
|
//-----------------------------------------------------------------------------
|
|
static void CheckDuplicateNodeIDs(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
EnumChildrenPos_t pos;
|
|
CMapClass *pChild = pWorld->GetFirstDescendent(pos);
|
|
while (pChild != NULL)
|
|
{
|
|
CMapEntity *pEntity = dynamic_cast<CMapEntity *>(pChild);
|
|
if (pEntity && pEntity->IsNodeClass())
|
|
{
|
|
if (FindDuplicateNodeID(pEntity, pWorld))
|
|
{
|
|
AddError(pList, ErrorDuplicateNodeIDs, (DWORD)pWorld, pEntity);
|
|
}
|
|
}
|
|
|
|
pChild = pWorld->GetNextDescendent(pos);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks for faces with identical face normals in this solid object.
|
|
// Input : pSolid - Solid to check for duplicate faces.
|
|
// Output : Returns TRUE if the face contains at least one duplicate face,
|
|
// FALSE if the solid contains no duplicate faces.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL DoesContainDuplicates(CMapSolid *pSolid)
|
|
{
|
|
int iFaces = pSolid->GetFaceCount();
|
|
for (int i = 0; i < iFaces; i++)
|
|
{
|
|
CMapFace *pFace = pSolid->GetFace(i);
|
|
Vector& pts1 = pFace->plane.normal;
|
|
|
|
for (int j = 0; j < iFaces; j++)
|
|
{
|
|
// Don't check self.
|
|
if (j == i)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
CMapFace *pFace2 = pSolid->GetFace(j);
|
|
Vector& pts2 = pFace2->plane.normal;
|
|
|
|
if (pts1 == pts2)
|
|
{
|
|
return(TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pSolid -
|
|
// pList -
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckDuplicatePlanes(CMapSolid *pSolid, CListBox *pList)
|
|
{
|
|
if ( !IsCheckVisible( pSolid ) )
|
|
return TRUE;
|
|
|
|
if (DoesContainDuplicates(pSolid))
|
|
{
|
|
AddError(pList, ErrorDuplicatePlanes, 0, pSolid);
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
static void CheckDuplicatePlanes(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckDuplicatePlanes, (DWORD)pList, MAPCLASS_TYPE(CMapSolid));
|
|
}
|
|
|
|
|
|
struct FindDuplicateFaceIDs_t
|
|
{
|
|
CMapFaceList All; // Collects all the face IDs in this map.
|
|
CMapFaceList Duplicates; // Collects the duplicate face IDs in this map.
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pSolid -
|
|
// pData -
|
|
// Output : Returns TRUE to continue enumerating.
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckDuplicateFaceIDs(CMapSolid *pSolid, FindDuplicateFaceIDs_t *pData)
|
|
{
|
|
if ( !IsCheckVisible( pSolid ) )
|
|
return TRUE;
|
|
|
|
int nFaceCount = pSolid->GetFaceCount();
|
|
for (int i = 0; i < nFaceCount; i++)
|
|
{
|
|
CMapFace *pFace = pSolid->GetFace(i);
|
|
if (pData->All.FindFaceID(pFace->GetFaceID()) != -1)
|
|
{
|
|
if (pData->Duplicates.FindFaceID(pFace->GetFaceID()) != -1)
|
|
{
|
|
pData->Duplicates.AddToTail(pFace);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pData->All.AddToTail(pFace);
|
|
}
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Reports errors for all faces with duplicate face IDs.
|
|
// Input : pList -
|
|
// pWorld -
|
|
//-----------------------------------------------------------------------------
|
|
static void CheckDuplicateFaceIDs(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
FindDuplicateFaceIDs_t Lists;
|
|
Lists.All.SetGrowSize(128);
|
|
Lists.Duplicates.SetGrowSize(128);
|
|
|
|
pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckDuplicateFaceIDs, (DWORD)&Lists, MAPCLASS_TYPE(CMapSolid));
|
|
|
|
for (int i = 0; i < Lists.Duplicates.Count(); i++)
|
|
{
|
|
CMapFace *pFace = Lists.Duplicates.Element(i);
|
|
AddError(pList, ErrorDuplicateFaceIDs, (DWORD)pFace, (CMapSolid *)pFace->GetParent());
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Checks if a particular target is valid.
|
|
//-----------------------------------------------------------------------------
|
|
static void CheckValidTarget(CMapEntity *pEntity, const char *pFieldName, const char *pTargetName, CListBox *pList, bool bCheckClassNames)
|
|
{
|
|
if (!pTargetName)
|
|
return;
|
|
|
|
// These procedural names are always assumed to exist.
|
|
if (!stricmp(pTargetName, "!activator") || !stricmp(pTargetName, "!caller") || !stricmp(pTargetName, "!player") || !stricmp(pTargetName, "!self"))
|
|
return;
|
|
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
|
|
// Search by name first.
|
|
CMapEntityList Found;
|
|
bool bFound = pDoc->FindEntitiesByName(Found, pTargetName, (Options.general.bCheckVisibleMapErrors == TRUE));
|
|
if (!bFound && bCheckClassNames)
|
|
{
|
|
// Not found, search by classname.
|
|
bFound = pDoc->FindEntitiesByClassName(Found, pTargetName, (Options.general.bCheckVisibleMapErrors == TRUE));
|
|
}
|
|
|
|
if (!bFound)
|
|
{
|
|
// No dice, flag it as an error.
|
|
AddError(pList, ErrorMissingTarget, (DWORD)pFieldName, pEntity);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks the given entity for references by name to nonexistent entities.
|
|
// Input : pEntity -
|
|
// pList -
|
|
// Output : Returns TRUE to keep enumerating.
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckMissingTargets(CMapEntity *pEntity, CListBox *pList)
|
|
{
|
|
if ( !IsCheckVisible( pEntity ) )
|
|
return TRUE;
|
|
|
|
GDclass *pClass = pEntity->GetClass();
|
|
if (!pClass)
|
|
{
|
|
// Unknown class -- just check for target references.
|
|
static char *pszTarget = "target";
|
|
const char *pszValue = pEntity->GetKeyValue(pszTarget);
|
|
CheckValidTarget(pEntity, pszTarget, pszValue, pList, false);
|
|
}
|
|
else
|
|
{
|
|
// Known class -- check all target_destination and target_name_or_class keyvalues.
|
|
for (int i = 0; i < pClass->GetVariableCount(); i++)
|
|
{
|
|
GDinputvariable *pVar = pClass->GetVariableAt(i);
|
|
if ((pVar->GetType() != ivTargetDest) && (pVar->GetType() != ivTargetNameOrClass))
|
|
continue;
|
|
|
|
const char *pszValue = pEntity->GetKeyValue(pVar->GetName());
|
|
CheckValidTarget(pEntity, pVar->GetName(), pszValue, pList, (pVar->GetType() == ivTargetNameOrClass));
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void CheckMissingTargets(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckMissingTargets, (DWORD)pList, MAPCLASS_TYPE(CMapEntity));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determines whether a solid is good or bad.
|
|
// Input : pSolid - Solid to check.
|
|
// pList - List box into which to place errors.
|
|
// Output : Always returns TRUE to continue enumerating.
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckSolidIntegrity(CMapSolid *pSolid, CListBox *pList)
|
|
{
|
|
if ( !IsCheckVisible( pSolid ) )
|
|
return TRUE;
|
|
|
|
CCheckFaceInfo cfi;
|
|
int nFaces = pSolid->GetFaceCount();
|
|
for (int i = 0; i < nFaces; i++)
|
|
{
|
|
CMapFace *pFace = pSolid->GetFace(i);
|
|
|
|
//
|
|
// Reset the iPoint member so results from previous faces don't carry over.
|
|
//
|
|
cfi.iPoint = -1;
|
|
|
|
//
|
|
// Check the face.
|
|
//
|
|
if (!pFace->CheckFace(&cfi))
|
|
{
|
|
AddError(pList, ErrorSolidStructure, 0, pSolid);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
static void CheckSolidIntegrity(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckSolidIntegrity, (DWORD)pList, MAPCLASS_TYPE(CMapSolid));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pSolid -
|
|
// pList -
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckSolidContents(CMapSolid *pSolid, CListBox *pList)
|
|
{
|
|
if ( !IsCheckVisible( pSolid ) )
|
|
return TRUE;
|
|
|
|
CCheckFaceInfo cfi;
|
|
int nFaces = pSolid->GetFaceCount();
|
|
CMapFace *pFace = pSolid->GetFace(0);
|
|
DWORD dwContents = pFace->texture.q2contents;
|
|
|
|
for (int i = 1; i < nFaces; i++)
|
|
{
|
|
pFace = pSolid->GetFace(i);
|
|
if (pFace->texture.q2contents == dwContents)
|
|
{
|
|
continue;
|
|
}
|
|
AddError(pList, ErrorSolidContents, 0, pSolid);
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void CheckSolidContents(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
if (CMapDoc::GetActiveMapDoc() && CMapDoc::GetActiveMapDoc()->GetGame() && CMapDoc::GetActiveMapDoc()->GetGame()->mapformat == mfQuake2)
|
|
{
|
|
pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckSolidContents, (DWORD)pList, MAPCLASS_TYPE(CMapSolid));
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determines if there are any invalid textures or texture axes on any
|
|
// face of this solid. Adds an error message to the list box for each
|
|
// error found.
|
|
// Input : pSolid - Solid to check.
|
|
// pList - Pointer to the error list box.
|
|
// Output : Returns TRUE.
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckInvalidTextures(CMapSolid *pSolid, CListBox *pList)
|
|
{
|
|
if ( !IsCheckVisible( pSolid ) )
|
|
return TRUE;
|
|
|
|
int nFaces = pSolid->GetFaceCount();
|
|
for(int i = 0; i < nFaces; i++)
|
|
{
|
|
const CMapFace *pFace = pSolid->GetFace(i);
|
|
|
|
IEditorTexture *pTex = pFace->GetTexture();
|
|
if (pTex->IsDummy())
|
|
{
|
|
AddError(pList, ErrorInvalidTexture, (DWORD)pFace->texture.texture, pSolid);
|
|
return TRUE;
|
|
}
|
|
|
|
if (!pFace->IsTextureAxisValid())
|
|
{
|
|
AddError(pList, ErrorInvalidTextureAxes, i, pSolid);
|
|
return(TRUE);
|
|
}
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
static void CheckInvalidTextures(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckInvalidTextures, (DWORD)pList, MAPCLASS_TYPE(CMapSolid));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pEntity -
|
|
// pList -
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckUnusedKeyvalues(CMapEntity *pEntity, CListBox *pList)
|
|
{
|
|
if ( !IsCheckVisible( pEntity ) )
|
|
return TRUE;
|
|
|
|
if (!pEntity->IsClass() || pEntity->IsClass("multi_manager"))
|
|
{
|
|
return(TRUE); // can't check if no class associated
|
|
}
|
|
|
|
GDclass *pClass = pEntity->GetClass();
|
|
|
|
for (int i = pEntity->GetFirstKeyValue(); i != pEntity->GetInvalidKeyValue(); i=pEntity->GetNextKeyValue( i ) )
|
|
{
|
|
if (pClass->VarForName(pEntity->GetKey(i)) == NULL)
|
|
{
|
|
AddError(pList, ErrorUnusedKeyvalues, (DWORD)pEntity->GetKey(i), pEntity);
|
|
return(TRUE);
|
|
}
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
static void CheckUnusedKeyvalues(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckUnusedKeyvalues, (DWORD)pList, MAPCLASS_TYPE(CMapEntity));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pEntity -
|
|
// pList -
|
|
// Output :
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckEmptyEntities(CMapEntity *pEntity, CListBox *pList)
|
|
{
|
|
if ( !IsCheckVisible( pEntity ) )
|
|
return TRUE;
|
|
|
|
if(!pEntity->IsPlaceholder() && !pEntity->GetChildCount())
|
|
{
|
|
AddError(pList, ErrorEmptyEntity, (DWORD)pEntity->GetClassName(), pEntity);
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
static void CheckEmptyEntities(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckEmptyEntities, (DWORD)pList, MAPCLASS_TYPE(CMapEntity));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks the entity for bad I/O connections.
|
|
// Input : pEntity - the entity to check
|
|
// pList - list box that tracks the errors
|
|
// Output : Returns TRUE to keep enumerating.
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckBadConnections(CMapEntity *pEntity, CListBox *pList)
|
|
{
|
|
if ( !IsCheckVisible( pEntity ) )
|
|
return TRUE;
|
|
|
|
if (CEntityConnection::ValidateOutputConnections(pEntity, (Options.general.bCheckVisibleMapErrors == TRUE)) == CONNECTION_BAD)
|
|
{
|
|
AddError(pList, ErrorBadConnections, (DWORD)pEntity->GetClassName(), pEntity);
|
|
}
|
|
|
|
// TODO: Check for a "Kill" input with the same output, target, and delay as another input. This
|
|
// creates a race condition in the game where the order of arrival is not guaranteed
|
|
//int nConnCount = pEntity->Connections_GetCount();
|
|
//for (int i = 0; i < nConnCount; i++)
|
|
//{
|
|
// CEntityConnection *pConn = pEntity->Connections_Get(i);
|
|
// if (!stricmp(pConn->GetInputName(), "kill"))
|
|
// {
|
|
// }
|
|
//}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void CheckBadConnections(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
pWorld->EnumChildren((ENUMMAPCHILDRENPROC)_CheckBadConnections, (DWORD)pList, MAPCLASS_TYPE(CMapEntity));
|
|
}
|
|
|
|
|
|
static bool HasVisGroupHiddenChildren(CMapClass *pObject)
|
|
{
|
|
const CMapObjectList *pChildren = pObject->GetChildren();
|
|
|
|
FOR_EACH_OBJ( *pChildren, pos )
|
|
{
|
|
if (!pChildren->Element(pos)->IsVisGroupShown())
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
static bool HasVisGroupShownChildren(CMapClass *pObject)
|
|
{
|
|
const CMapObjectList *pChildren = pObject->GetChildren();
|
|
FOR_EACH_OBJ( *pChildren, pos )
|
|
{
|
|
if (pChildren->Element(pos)->IsVisGroupShown())
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Makes sure that the visgroup assignments are valid.
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckVisGroups(CMapClass *pObject, CListBox *pList)
|
|
{
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
|
|
// dvs: FIXME: not working yet, revisit
|
|
// Entities cannot have hidden children.
|
|
//CMapEntity *pEntity = dynamic_cast<CMapEntity *>(pObject);
|
|
//if (pEntity && HasVisGroupHiddenChildren(pEntity))
|
|
//{
|
|
// AddError(pList, ErrorHiddenChildOfEntity, 0, pEntity);
|
|
// return TRUE;
|
|
//}
|
|
|
|
// Check the validity of any object that claims to be hidden by visgroups.
|
|
if (!pObject->IsVisGroupShown())
|
|
{
|
|
// Groups cannot be hidden by visgroups.
|
|
if (pObject->IsGroup())
|
|
{
|
|
bool bHidden = HasVisGroupHiddenChildren(pObject);
|
|
bool bVisible = HasVisGroupShownChildren(pObject);
|
|
|
|
if (bHidden && !bVisible)
|
|
{
|
|
AddError(pList, ErrorHiddenGroupHiddenChildren, 0, pObject);
|
|
}
|
|
else if (!bHidden && bVisible)
|
|
{
|
|
AddError(pList, ErrorHiddenGroupVisibleChildren, 0, pObject);
|
|
}
|
|
else
|
|
{
|
|
AddError(pList, ErrorHiddenGroupMixedChildren, 0, pObject);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Check for unanticipated objects that are hidden but forbidden from visgroup membership.
|
|
if (!pDoc->VisGroups_ObjectCanBelongToVisGroup(pObject))
|
|
{
|
|
AddError(pList, ErrorIllegallyHiddenObject, 0, pObject);
|
|
return TRUE;
|
|
}
|
|
|
|
// Hidden objects must belong to at least one visgroup.
|
|
if (pObject->GetVisGroupCount() == 0)
|
|
{
|
|
AddError(pList, ErrorHiddenObjectNoVisGroup, 0, pObject);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static void CheckVisGroups(CListBox *pList, CMapWorld *pWorld)
|
|
{
|
|
pWorld->EnumChildrenRecurseGroupsOnly((ENUMMAPCHILDRENPROC)_CheckVisGroups, (DWORD)pList);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
static BOOL _CheckOverlayFaceList( CMapEntity *pEntity, CListBox *pList )
|
|
{
|
|
if ( !IsCheckVisible( pEntity ) )
|
|
return TRUE;
|
|
|
|
const CMapObjectList *pChildren = pEntity->GetChildren();
|
|
|
|
FOR_EACH_OBJ( *pChildren, pos )
|
|
{
|
|
CMapOverlay *pOverlay = dynamic_cast<CMapOverlay*>( pChildren->Element(pos) );
|
|
if ( pOverlay )
|
|
{
|
|
// Check to see if the overlay has assigned faces.
|
|
if ( pOverlay->GetFaceCount() <= 0 )
|
|
{
|
|
AddError( pList, ErrorOverlayFaceList, 0, pEntity );
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
static void CheckOverlayFaceList( CListBox *pList, CMapWorld *pWorld )
|
|
{
|
|
pWorld->EnumChildren( ( ENUMMAPCHILDRENPROC )_CheckOverlayFaceList, ( DWORD )pList, MAPCLASS_TYPE( CMapEntity ));
|
|
}
|
|
|
|
//
|
|
// ** FIX FUNCTIONS
|
|
//
|
|
static void FixDuplicatePlanes(MapError *pError)
|
|
{
|
|
// duplicate planes in pObjects[0]
|
|
// run thru faces..
|
|
|
|
CMapSolid *pSolid = (CMapSolid*) pError->pObjects[0];
|
|
|
|
ReStart:
|
|
int iFaces = pSolid->GetFaceCount();
|
|
for(int i = 0; i < iFaces; i++)
|
|
{
|
|
CMapFace *pFace = pSolid->GetFace(i);
|
|
Vector& pts1 = pFace->plane.normal;
|
|
for (int j = 0; j < iFaces; j++)
|
|
{
|
|
// Don't check self
|
|
if (j == i)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
CMapFace *pFace2 = pSolid->GetFace(j);
|
|
Vector& pts2 = pFace2->plane.normal;
|
|
if (pts1 == pts2)
|
|
{
|
|
pSolid->DeleteFace(j);
|
|
goto ReStart;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Repairs an invalid solid.
|
|
// Input : pError - Contains information about the error.
|
|
//-----------------------------------------------------------------------------
|
|
static void FixSolidStructure(MapError *pError)
|
|
{
|
|
CMapSolid *pSolid = (CMapSolid *)pError->pObjects[0];
|
|
|
|
//
|
|
// First make sure all the faces are good.
|
|
//
|
|
int nFaces = pSolid->GetFaceCount();
|
|
for (int i = nFaces - 1; i >= 0; i--)
|
|
{
|
|
CMapFace *pFace = pSolid->GetFace(i);
|
|
if (!pFace->CheckFace(NULL))
|
|
{
|
|
pFace->Fix();
|
|
}
|
|
//
|
|
// If the face has no points, just remove it from the solid.
|
|
//
|
|
if (pFace->GetPointCount() == 0)
|
|
{
|
|
pSolid->DeleteFace(i);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Rebuild the solid from the planes.
|
|
//
|
|
pSolid->CreateFromPlanes();
|
|
pSolid->PostUpdate(Notify_Changed);
|
|
}
|
|
|
|
|
|
LPCTSTR GetDefaultTextureName(); // dvs: BAD!
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Replaces any missing textures with the default texture.
|
|
// Input : pError -
|
|
//-----------------------------------------------------------------------------
|
|
static void FixInvalidTexture(MapError *pError)
|
|
{
|
|
CMapSolid *pSolid = (CMapSolid *)pError->pObjects[0];
|
|
|
|
int nFaces = pSolid->GetFaceCount();
|
|
for (int i = 0; i < nFaces; i++)
|
|
{
|
|
CMapFace *pFace = pSolid->GetFace(i);
|
|
if (pFace != NULL)
|
|
{
|
|
IEditorTexture *pTex = pFace->GetTexture();
|
|
if (pTex != NULL)
|
|
{
|
|
if (pTex->IsDummy())
|
|
{
|
|
pFace->SetTexture(GetDefaultTextureName());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void FixInvalidTextureAxes(MapError *pError)
|
|
{
|
|
CMapSolid *pSolid = (CMapSolid *)pError->pObjects[0];
|
|
|
|
int nFaces = pSolid->GetFaceCount();
|
|
for (int i = 0; i < nFaces; i++)
|
|
{
|
|
CMapFace *pFace = pSolid->GetFace(i);
|
|
if (!pFace->IsTextureAxisValid())
|
|
{
|
|
pFace->InitializeTextureAxes(Options.GetTextureAlignment(), INIT_TEXTURE_FORCE | INIT_TEXTURE_AXES);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void FixInvalidContents(MapError *pError)
|
|
{
|
|
CMapSolid *pSolid = (CMapSolid *)pError->pObjects[0];
|
|
|
|
CMapFace *pFace = pSolid->GetFace(0);
|
|
DWORD dwContents = pFace->texture.q2contents;
|
|
|
|
int nFaces = pSolid->GetFaceCount();
|
|
for (int i = 1; i < nFaces; i++)
|
|
{
|
|
pFace = pSolid->GetFace(i);
|
|
pFace->texture.q2contents = dwContents;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Fixes duplicate face IDs by assigning the face a unique ID within
|
|
// the world.
|
|
// Input : pError - Holds the world and the face that is in error.
|
|
//-----------------------------------------------------------------------------
|
|
static void FixDuplicateFaceIDs(MapError *pError)
|
|
{
|
|
CMapWorld *pWorld = (CMapWorld *)pError->pObjects[0];
|
|
CMapFace *pFace = (CMapFace *)pError->dwExtra;
|
|
|
|
pFace->SetFaceID(pWorld->FaceID_GetNext());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pError -
|
|
//-----------------------------------------------------------------------------
|
|
static void FixUnusedKeyvalues(MapError *pError)
|
|
{
|
|
CMapEntity *pEntity = (CMapEntity*) pError->pObjects[0];
|
|
|
|
GDclass *pClass = pEntity->GetClass();
|
|
if (!pClass)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int iNext;
|
|
for ( int i=pEntity->GetFirstKeyValue(); i != pEntity->GetInvalidKeyValue(); i = iNext )
|
|
{
|
|
iNext = pEntity->GetNextKeyValue( i );
|
|
if (pClass->VarForName(pEntity->GetKey(i)) == NULL)
|
|
{
|
|
pEntity->DeleteKeyValue(pEntity->GetKey(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Removes any bad connections from the entity associated with the error.
|
|
// Input : pError -
|
|
//-----------------------------------------------------------------------------
|
|
static void FixBadConnections(MapError *pError)
|
|
{
|
|
CMapEntity *pEntity = (CMapEntity *)pError->pObjects[0];
|
|
CEntityConnection::FixBadConnections(pEntity, (Options.general.bCheckVisibleMapErrors == TRUE));
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Fixes a race condition caused by a Kill input being triggered at the
|
|
// same instant as another input.
|
|
// Input : pError -
|
|
//-----------------------------------------------------------------------------
|
|
static void FixKillInputRaceCondition(MapError *pError)
|
|
{
|
|
CEntityConnection *pConn = (CEntityConnection *)pError->pObjects[1];
|
|
|
|
// Delay the Kill command so that it arrives after the other command,
|
|
// solving the race condition.
|
|
pConn->SetDelay(pConn->GetDelay() + 0.01);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pError -
|
|
//-----------------------------------------------------------------------------
|
|
static void FixOverlayFaceList( MapError *pError )
|
|
{
|
|
CMapEntity *pEntity = static_cast<CMapEntity*>( pError->pObjects[0] );
|
|
if ( !pEntity )
|
|
return;
|
|
|
|
const CMapObjectList *pChildren = pEntity->GetChildren();
|
|
|
|
FOR_EACH_OBJ( *pChildren, pos )
|
|
{
|
|
CMapOverlay *pOverlay = dynamic_cast<CMapOverlay*>( pChildren->Element(pos) );
|
|
if ( pOverlay )
|
|
{
|
|
// Destroy itself.
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
pDoc->RemoveObjectFromWorld( pEntity, true );
|
|
GetHistory()->KeepForDestruction( pEntity );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pError -
|
|
//-----------------------------------------------------------------------------
|
|
static void FixEmptyEntity(MapError *pError)
|
|
{
|
|
CMapClass *pKillMe = pError->pObjects[0];
|
|
|
|
if (pKillMe->GetParent() != NULL)
|
|
{
|
|
GetHistory()->KeepForDestruction(pKillMe);
|
|
pKillMe->GetParent()->RemoveChild(pKillMe);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Fixes duplicate node IDs by assigning the entity a unique node ID.
|
|
// Input : pError - Holds the world and the entity that is in error.
|
|
//-----------------------------------------------------------------------------
|
|
static void FixDuplicateNodeIDs(MapError *pError)
|
|
{
|
|
CMapEntity *pEntity = (CMapEntity *)pError->pObjects[0];
|
|
pEntity->AssignNodeID();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Clears a bad target reference from the given entity.
|
|
// Input : pError -
|
|
//-----------------------------------------------------------------------------
|
|
static void FixMissingTarget(MapError *pError)
|
|
{
|
|
CMapEntity *pEntity = (CMapEntity *)pError->pObjects[0];
|
|
const char *pszKey = (const char *)pError->dwExtra;
|
|
pEntity->SetKeyValue(pszKey, NULL);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Fix a an invalid visgroup state. This is either:
|
|
// 1) A group that is hidden
|
|
// 2) An object that is hidden but not in any visgroups
|
|
//-----------------------------------------------------------------------------
|
|
void FixHiddenObject(MapError *pError)
|
|
{
|
|
CMapClass *pObject = pError->pObjects[0];
|
|
|
|
// Tweak the object's visgroup state directly to avoid changing the
|
|
// hidden/shown state of the object's children.
|
|
pObject->m_bVisGroupShown = true;
|
|
pObject->m_bVisGroupAutoShown = true;
|
|
pObject->m_VisGroups.RemoveAll();
|
|
|
|
// Create a new visgroup to out the objects in (for hiding or inspection/deletion).
|
|
CMapObjectList Objects;
|
|
Objects.AddToTail(pObject);
|
|
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
|
|
|
|
if ((pError->Type == ErrorHiddenGroupHiddenChildren) ||
|
|
(pError->Type == ErrorHiddenObjectNoVisGroup))
|
|
{
|
|
// The objects aren't in the compile, so just hide them.
|
|
pDoc->VisGroups_CreateNamedVisGroup(Objects, "_hidden by Check for Problems", true, false);
|
|
}
|
|
else if (pError->Type == ErrorIllegallyHiddenObject)
|
|
{
|
|
// Do nothing, the object is now shown.
|
|
}
|
|
else
|
|
{
|
|
// ErrorHiddenGroupVisibleChildren
|
|
// ErrorHiddenGroupMixedChildren
|
|
// ErrorHiddenChildOfEntity
|
|
|
|
// The objects either ARE in the compile, or they can't be hidden in a visgroup.
|
|
// Don't hide them, just stick them in a visgroup for inspection
|
|
pDoc->VisGroups_CreateNamedVisGroup(Objects, "found by Check for Problems", false, false);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Checks the map for problems. Returns true if the map is okay,
|
|
// false if problems were found.
|
|
//-----------------------------------------------------------------------------
|
|
bool CMapCheckDlg::DoCheck(void)
|
|
{
|
|
CMapWorld *pWorld = GetActiveWorld();
|
|
|
|
// Clear error list
|
|
KillErrorList();
|
|
|
|
// Map validation
|
|
CheckRequirements(&m_Errors, pWorld);
|
|
|
|
// Solid validation
|
|
CheckMixedFaces(&m_Errors, pWorld);
|
|
//CheckDuplicatePlanes(&m_Errors, pWorld);
|
|
CheckDuplicateFaceIDs(&m_Errors, pWorld);
|
|
CheckDuplicateNodeIDs(&m_Errors, pWorld);
|
|
CheckSolidIntegrity(&m_Errors, pWorld);
|
|
CheckSolidContents(&m_Errors, pWorld);
|
|
CheckInvalidTextures(&m_Errors, pWorld);
|
|
|
|
// Entity validation
|
|
CheckUnusedKeyvalues(&m_Errors, pWorld);
|
|
CheckEmptyEntities(&m_Errors, pWorld);
|
|
CheckMissingTargets(&m_Errors, pWorld);
|
|
CheckBadConnections(&m_Errors, pWorld);
|
|
|
|
CheckVisGroups(&m_Errors, pWorld);
|
|
|
|
CheckOverlayFaceList(&m_Errors, pWorld);
|
|
|
|
if (!m_Errors.GetCount())
|
|
{
|
|
AfxMessageBox("No errors were found.");
|
|
EndDialog(IDOK);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::OnOK()
|
|
{
|
|
DestroyWindow();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::OnClose()
|
|
{
|
|
DestroyWindow();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called when our window is being destroyed.
|
|
//-----------------------------------------------------------------------------
|
|
void CMapCheckDlg::OnDestroy()
|
|
{
|
|
delete this;
|
|
s_pDlg = NULL;
|
|
}
|