//-----------------------------------------------------------------------------
// Purpose: Links to any matching Source entities
//-----------------------------------------------------------------------------
void CEntityConnection::LinkSourceEntities()
{
// Empty out the existing entity list
m_pSourceEntityList->RemoveAll();
// Get a list of all the entities in the world
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if (pDoc)
{
CMapWorld *pWorld = pDoc->GetMapWorld();
if (pWorld)
{
CMapEntityList matches;
pWorld->FindEntitiesByName( matches, m_szSourceEntity, false );
for ( int i = 0; i < matches.Count(); i++ )
{
CMapEntity *pEntity = matches.Element( i );
m_pSourceEntityList->AddToTail( pEntity );
//pEntity->Connection_Add( this ); // This should already be true on creation, investigate need for this func
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Constructor. Initializes data members.
//-----------------------------------------------------------------------------
CMapClass::CMapClass(void)
{
m_pSafeObject = CSafeObject<CMapClass>::Create( this );
//
// The document manages the unique object IDs. Eventually all object construction
// should be done through the document, eliminating the need for CMapClass to know
// about CMapDoc.
//
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if (pDoc != NULL)
{
m_nID = pDoc->GetNextMapObjectID();
}
else
{
m_nID = 0;
}
dwKept = 0;
m_bTemporary = FALSE;
m_bVisible = true;
m_bVisible2D = true;
m_bVisGroupShown = true;
m_bVisGroupAutoShown = true;
m_pColorVisGroup = NULL;
r = g = b = 220;
m_pParent = NULL;
m_nRenderFrame = 0;
m_pEditorKeys = NULL;
m_Dependents.Purge();
}
void CMapView::DrawMegaTile(CDC* pDC, int x, int y)
{
CMapDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
int r = y * pDoc->GetWidth() + x;
CTile Tile = pDoc->GetTile(r);
if (m_ViewMode == VIEW_MODE_TILES)
{
for (int ye = 0; ye < 4; ye++)
{
for (int xe = 0; xe < 4; xe++)
{
DrawTile(pDC, x,y,xe,ye, Tile);
}
}
}
else
{
ASSERT(m_ViewMode == VIEW_MODE_ELEVATION);
BYTE v = (BYTE)(Tile.Elevation);
v = (BYTE)min(255, v*5); // make difference in color more noticable
pDC->FillSolidRect(x*40, y*40, 40,40, RGB(v,v,v));
}
}
//-----------------------------------------------------------------------------
// Purpose: Invokes the texture replace dialog.
//-----------------------------------------------------------------------------
void CFaceEditMaterialPage::OnReplace( void )
{
// Set the material tool current.
SetMaterialPageTool( MATERIALPAGETOOL_MATERIAL );
//
// get active map doc
//
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if( !pDoc )
return;
// ready the replace dialog
CReplaceTexDlg dlg( pDoc->GetSelection()->GetCount() );
// get the texture to replace -- the default texture?!
dlg.m_strFind = GetDefaultTextureName();
//
// open replace dialog -- modal
//
if( dlg.DoModal() != IDOK )
return;
// mark undo position
GetHistory()->MarkUndoPosition( pDoc->GetSelection()->GetList(), "Replace Textures" );
if( dlg.m_bMarkOnly )
{
pDoc->SelectObject( NULL, scClear ); // clear selection first
}
dlg.DoReplaceTextures();
}
//-----------------------------------------------------------------------------
// Purpose: Constructor. Initializes data members.
//-----------------------------------------------------------------------------
CMapClass::CMapClass(void)
{
//
// The document manages the unique object IDs. Eventually all object construction
// should be done through the document, eliminating the need for CMapClass to know
// about CMapDoc.
//
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if (pDoc != NULL)
{
m_nID = pDoc->GetNextMapObjectID();
}
else
{
m_nID = 0;
}
dwKept = 0;
m_bVisible = true;
m_bVisible2D = true;
m_bTemporary = FALSE;
m_pVisGroup = NULL;
r = g = b = 220;
Parent = NULL;
m_nRenderFrame = 0;
m_bShouldSerialize = TRUE;
m_pEditorKeys = NULL;
}
void CMapView::OnRButtonDown(UINT, CPoint point)
{
CPoint pt = point + GetScrollPosition();
int x = pt.x / 40;
int y = pt.y / 40;
int xe = (pt.x % 40) / 10;
int ye = (pt.y % 40) / 10;
CMapDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
int w = pDoc->GetWidth();
int h = pDoc->GetHeight();
if (w > 0 && h > 0 && x >= 0 && y >= 0 && x < w && y < h && xe >= 0 && xe < 4 && ye >= 0 && ye < 4)
{
int r = y*w + x;
int e = ye*4 + xe;
CTile Tile = pDoc->GetTile(r);
g_Tile = Tile.E[e];
g_Elevation = Tile.Elevation;
CString str;
str.Format("Select %s (%dm) from %d [%d]", g_App.m_Elements[g_Tile].Name, g_Elevation, r,e);
g_App.PrintStatus(str);
}
}
//-----------------------------------------------------------------------------
// Purpose: Invokes the replace texture dialog.
//-----------------------------------------------------------------------------
void CTextureBrowser::OnReplace(void)
{
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if(!pDoc)
return;
CReplaceTexDlg dlg(pDoc->GetSelection()->GetCount());
dlg.m_strFind = m_cTextureWindow.szCurTexture;
if(dlg.DoModal() != IDOK)
return;
// mark undo position
GetHistory()->MarkUndoPosition(pDoc->GetSelection()->GetList(), "Replace Textures");
if(dlg.m_bMarkOnly)
{
pDoc->SelectObject(NULL, scClear); // clear selection first
}
dlg.DoReplaceTextures();
//EndDialog(IDOK);
if (m_bUsed)
{
SetUsed(TRUE);
}
}
//-----------------------------------------------------------------------------
// Purpose: Special implementation of UpdateChild for the world object. This
// notifies the document that an object's bounding box has changed.
// Input : pChild -
//-----------------------------------------------------------------------------
void CMapWorld::UpdateChild(CMapClass *pChild)
{
if ( CMapClass::s_bLoadingVMF )
return;
// Recalculate the bounds of this child's branch.
pChild->CalcBounds(TRUE);
// Recalculate own bounds
CalcBounds( FALSE );
//
// Relink the child in the culling tree.
//
if (m_pCullTree != NULL)
{
m_pCullTree->UpdateCullTreeObjectRecurse(pChild);
}
//
// Notify the document that an object in the world has changed.
//
if (!IsTemporary()) // HACK: check to avoid prefab objects ending up in the doc's update list
{
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if (pDoc != NULL)
{
pDoc->UpdateObject(pChild);
}
}
}
void CMapView::OnLButtonDown(UINT nFlags, CPoint point)
{
if (m_HandDown)
{
m_Tracking = true;
SetCapture();
m_LastPoint = point;
}
else
{
CPoint pt = point + GetScrollPosition();
int x = pt.x / 40;
int y = pt.y / 40;
int xe = (pt.x % 40) / 10;
int ye = (pt.y % 40) / 10;
CMapDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
int w = pDoc->GetWidth();
int h = pDoc->GetHeight();
if (w > 0 && h > 0 && x >= 0 && y >= 0 && x < w && y < h && xe >= 0 && xe < 4 && ye >= 0 && ye < 4)
{
int r = y*w + x;
int e = ye*4 + xe;
if (m_ViewMode == VIEW_MODE_ELEVATION)
{
pDoc->SetTileElevation(r, g_Elevation);
CString str;
str.Format("Change %d to %dm", r, g_Elevation);
g_App.PrintStatus(str);
CRect rect(CPoint(x*40, y*40), CSize(40,40));
rect.OffsetRect(-GetScrollPosition());
InvalidateRect(rect, FALSE);
}
else
{
pDoc->SetTile(r,e, g_Tile);
CString str;
str.Format("Change %d [%d] to %s", r,e, g_App.m_Elements[g_Tile].Name);
g_App.PrintStatus(str);
CRect rect(CPoint(x*40 + xe*10, y*40 + ye*10), CSize(10,10));
rect.OffsetRect(-GetScrollPosition());
InvalidateRect(rect, FALSE);
}
m_Tracking = true;
SetCapture();
}
}
Inherited::OnLButtonDown(nFlags, point);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTextureBrowser::OnMark(void)
{
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if (pDoc != NULL)
{
pDoc->ReplaceTextures(m_cTextureWindow.szCurTexture, "", TRUE, 0x100, FALSE, FALSE);
EndDialog(IDOK);
}
}
CToolManager* ToolManager()
{
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if ( pDoc )
return pDoc->GetTools();
return &s_DummyToolmanager;
}
void CMapView::OnInitialUpdate()
{
Inherited::OnInitialUpdate();
CMapDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
int h = pDoc->GetHeight();
int w = pDoc->GetWidth();
SetScrollSizes(MM_TEXT, CSize(w*40, h*40));
}
//-----------------------------------------------------------------------------
// 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);
str.LoadString(ID_DESCRIPTIONS_START + pError->Type);
m_Description.SetSel(0, -1);
m_Description.ReplaceSel(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->Selection_SetMode(selectObjects);
if (pError->pObjects[0])
{
pDoc->SelectObject(pError->pObjects[0], CMapDoc::scClear | CMapDoc::scSelect | CMapDoc::scUpdateDisplay);
}
else
{
pDoc->SelectObject(NULL, CMapDoc::scClear | CMapDoc::scUpdateDisplay);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void COP_Groups::UpdateGrouplist(void)
{
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if (pDoc == NULL)
{
return;
}
if(!::IsWindow(m_cGroups.m_hWnd))
return;
int iSel = m_cGroups.GetCurSel();
DWORD oldselid = 0xffffffff;
if(iSel != LB_ERR)
oldselid = m_cGroups.GetItemData(iSel);
m_cGroups.ResetContent();
if (IsMultiEdit())
{
m_cGroups.InsertString(0, VALUE_DIFFERENT_STRING);
m_cGroups.SetItemData(0, VALUE_DIFFERENT_ID);
}
m_cGroups.InsertString(0, NO_GROUP_STRING);
m_cGroups.SetItemData(0, NO_GROUP_ID);
POSITION pos = pDoc->VisGroups_GetHeadPosition();
while (pos != NULL)
{
CVisGroup *pGroup = pDoc->VisGroups_GetNext(pos);
int iIndex = m_cGroups.AddString(pGroup->GetName());
m_cGroups.SetItemData(iIndex, pGroup->GetID());
}
// restore old selection based on stored id
iSel = 0;
int iSize = m_cGroups.GetCount();
for(int i = 0; i < iSize; i++)
{
if(m_cGroups.GetItemData(i) == oldselid)
{
iSel = i;
break;
}
}
m_cGroups.SetCurSel(iSel);
m_cGroups.Invalidate();
}
void CPrefabsDlg::EditObjectData()
{
// get application
CHammer *pApp = (CHammer*) AfxGetApp();
if(bCurLibraryModified)
{
CPrefabLibrary *pLibrary = GetCurrentLibrary();
if(pLibrary)
pLibrary->Save();
}
CMapDoc *pDoc = (CMapDoc*) pApp->pMapDocTemplate->OpenDocumentFile(NULL);
pDoc->EditPrefab3D(GetCurrentObject()->GetID());
EndDialog(IDOK);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pView -
// nFlags -
// point -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool Marker3D::OnLMouseDown2D(CMapView2D *pView, UINT nFlags, CPoint point)
{
CMapDoc *pDoc = pView->GetDocument();
if (pDoc == NULL)
{
return true;
}
CMapWorld *pWorld = pDoc->GetMapWorld();
m_bLButtonDown = true;
pView->SetCapture();
//
// Convert to some odd coordinate space that the base tools code uses.
//
CPoint ptScreen = point;
ptScreen.x += pView->GetScrollPos(SB_HORZ);
ptScreen.y += pView->GetScrollPos(SB_VERT);
//
// Convert point to world coords.
//
pView->ClientToWorld(point);
Vector ptOrg = vec3_origin;
ptOrg[axHorz] = point.x;
ptOrg[axVert] = point.y;
//
// Snap starting position to grid.
//
if (!(GetAsyncKeyState(VK_MENU) & 0x8000))
{
pDoc->Snap(ptOrg);
}
StartNew(ptOrg);
pView->SetUpdateFlag(CMapView2D::updTool);
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pView -
// nFlags -
// point -
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool CToolMaterial::OnLMouseDown2D(CMapView2D *pView, UINT nFlags, CPoint point)
{
CMapDoc *pDoc = pView->GetDocument();
CMapWorld *pWorld = pDoc->GetMapWorld();
if (nFlags & MK_CONTROL)
{
//
// CONTROL is down, perform selection only.
//
pView->SelectAt(point, FALSE, true);
}
else
{
pView->SelectAt(point, TRUE, true);
}
return (true);
}
//-----------------------------------------------------------------------------
// Purpose: Handles left mouse button down events in the 3D view.
// Input : Per CWnd::OnLButtonDown.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool CToolMaterial::OnLMouseDown3D(CMapView3D *pView, UINT nFlags, CPoint point)
{
CMapDoc *pDoc = pView->GetDocument();
if (pDoc == NULL)
{
return false;
}
bool bShift = ((GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0);
ULONG ulFace;
CMapClass *pObject = pView->NearestObjectAt(point, ulFace);
if ((pObject != NULL) && (pObject->IsMapClass(MAPCLASS_TYPE(CMapSolid))))
{
CMapSolid *pSolid = (CMapSolid *)pObject;
int cmd = CMapDoc::scToggle | CMapDoc::scClear | CMapDoc::scUpdateDisplay;
// No clear if CTRL pressed.
if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
{
cmd &= ~CMapDoc::scClear;
}
// If they are holding down SHIFT, select the entire solid.
if (bShift)
{
pDoc->SelectFace(pSolid, -1, cmd);
}
// Otherwise, select a single face.
else
{
pDoc->SelectFace(pSolid, ulFace, cmd);
}
}
// Update the controls given new information (ie. new faces).
GetMainWnd()->m_pFaceEditSheet->UpdateControls();
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Causes all objects in the world to update any object dependencies (pointers)
// that they might be holding. This is a static function.
//-----------------------------------------------------------------------------
void CMapClass::UpdateAllDependencies(CMapClass *pObject)
{
//
// Try to locate the world object.
//
CMapWorld *pWorld;
if (pObject == NULL)
{
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if ((pDoc == NULL) || (pDoc->IsLoading()))
{
return;
}
pWorld = pDoc->GetMapWorld();
}
else
{
pWorld = pObject->GetWorldObject(pObject);
}
if (pWorld == NULL)
{
return;
}
//
// We found the world. Tell all its children to update their dependencies
// because of the given object.
//
EnumChildrenPos_t pos;
CMapClass *pChild = pWorld->GetFirstDescendent(pos);
while (pChild != NULL)
{
pChild->UpdateDependencies(pWorld, pObject);
pChild = pWorld->GetNextDescendent(pos);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapCheckDlg::OnGo()
{
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
// change description to match error
int iSel = m_Errors.GetCurSel();
if(iSel == LB_ERR)
return; // no sel
MapError *pError;
pError = (MapError*) m_Errors.GetItemDataPtr(iSel);
VIEW2DINFO vi;
vi.wFlags = VI_CENTER;
// get centerpoint
pError->pObjects[0]->GetBoundsCenter(vi.ptCenter);
g_pToolManager->SetTool(TOOL_POINTER);
pDoc->SelectObject(pError->pObjects[0], CMapDoc::scClear |
CMapDoc::scSelect | CMapDoc::scUpdateDisplay);
pDoc->SetView2dInfo(vi);
}
//-----------------------------------------------------------------------------
// Purpose: Called any time we are hidden or shown.
// Input : bShow -
// nStatus -
//-----------------------------------------------------------------------------
void CSearchReplaceDlg::OnShowWindow(BOOL bShow, UINT nStatus)
{
if (bShow)
{
m_bNewSearch = true;
GetDlgItem(IDCANCEL)->SetWindowText("Cancel");
m_nFindIn = FindInWorld;
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if (pDoc)
{
if (pDoc->Selection_GetCount() > 0)
{
m_nFindIn = FindInSelection;
}
}
// Populate the controls with the current data.
UpdateData(FALSE);
}
CDialog::OnShowWindow(bShow, nStatus);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nChar -
// nRepCnt -
// nFlags -
//-----------------------------------------------------------------------------
bool Clipper3D::OnKeyDown2D(CMapView2D *pView, UINT nChar, UINT nRepCnt, UINT nFlags)
{
switch (nChar)
{
case 'O':
{
//
// Toggle the rendering of measurements.
//
ToggleMeasurements();
CMapDoc *pDoc = pView->GetDocument();
pDoc->ToolUpdateViews(CMapView2D::updTool);
return true;
}
case VK_RETURN:
{
//
// Do the clip.
//
if (!IsEmpty() )
{
SaveClipResults();
}
return true;
}
case VK_ESCAPE:
{
OnEscape();
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pView -
// nFlags -
// point -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool Marker3D::OnLMouseDown3D(CMapView3D *pView, UINT nFlags, CPoint point)
{
ULONG ulFace;
CMapClass *pObject = pView->NearestObjectAt(point, ulFace);
if (pObject != NULL)
{
CMapSolid *pSolid = dynamic_cast <CMapSolid *> (pObject);
if (pSolid == NULL)
{
// Clicked on a point entity - do nothing.
return true;
}
CMapDoc *pDoc = pView->GetDocument();
//
// Build a ray to trace against the face that they clicked on to
// find the point of intersection.
//
Vector Start;
Vector End;
pView->BuildRay(point, Start, End);
Vector HitPos, HitNormal;
CMapFace *pFace = pSolid->GetFace(ulFace);
if (pFace->TraceLine(HitPos, HitNormal, Start, End))
{
if (GetMainWnd()->m_ObjectBar.IsEntityToolCreatingPrefab())
{
//
// Prefab creation.
//
pDoc->Snap(HitPos);
GetHistory()->MarkUndoPosition(pDoc->Selection_GetList(), "New Prefab");
// Get prefab object
CMapClass *pPrefabObject = GetMainWnd()->m_ObjectBar.BuildPrefabObjectAtPoint(HitPos);
//
// Add prefab to the world.
//
CMapWorld *pWorld = pDoc->GetMapWorld();
pDoc->ExpandObjectKeywords(pPrefabObject, pWorld);
pDoc->AddObjectToWorld(pPrefabObject);
GetHistory()->KeepNew(pPrefabObject);
//
// Select the new object.
//
pDoc->SelectObject(pPrefabObject, CMapDoc::scClear | CMapDoc::scSelect | CMapDoc::scUpdateDisplay);
//
// Update world bounds.
//
UpdateBox ub;
CMapObjectList ObjectList;
ObjectList.AddTail(pPrefabObject);
ub.Objects = &ObjectList;
Vector mins;
Vector maxs;
pPrefabObject->GetRender2DBox(mins, maxs);
ub.Box.SetBounds(mins, maxs);
pDoc->UpdateAllViews(NULL, MAPVIEW_UPDATE_OBJECTS, &ub);
pDoc->SetModifiedFlag();
}
else if (GetMainWnd()->m_ObjectBar.IsEntityToolCreatingEntity())
{
//
// Entity creation.
//
GetHistory()->MarkUndoPosition(pDoc->Selection_GetList(), "New Entity");
CMapEntity *pEntity = new CMapEntity;
pEntity->SetPlaceholder(TRUE);
pEntity->SetOrigin(HitPos);
pEntity->SetClass(CObjectBar::GetDefaultEntityClass());
//Align the entity on the plane properly
// pEntity->AlignOnPlane(HitPos, &pFace->plane, (pFace->plane.normal[2] > 0.0f) ? CMapEntity::ALIGN_BOTTOM : CMapEntity::ALIGN_TOP);
pEntity->AlignOnPlane(HitPos, &pFace->plane, (HitNormal[2] > 0.0f) ? CMapEntity::ALIGN_BOTTOM : CMapEntity::ALIGN_TOP);
CMapWorld *pWorld = pDoc->GetMapWorld();
pDoc->AddObjectToWorld(pEntity);
GetHistory()->KeepNew(pEntity);
//
// Select the new object.
//
pDoc->SelectObject(pEntity, CMapDoc::scClear | CMapDoc::scSelect | CMapDoc::scUpdateDisplay);
UpdateBox ub;
CMapObjectList ObjectList;
ObjectList.AddTail(pEntity);
ub.Objects = &ObjectList;
Vector mins;
Vector maxs;
pEntity->GetRender2DBox(mins, maxs);
ub.Box.SetBounds(mins, maxs);
pDoc->UpdateAllViews(NULL, MAPVIEW_UPDATE_OBJECTS, &ub);
pDoc->SetModifiedFlag();
}
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Handles left mouse button down events in the 2D view.
// Input : Per CWnd::OnLButtonDown.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool Clipper3D::OnLMouseDown2D(CMapView2D *pView, UINT nFlags, CPoint point)
{
CMapDoc *pDoc = pView->GetDocument();
CMapWorld *pWorld = pDoc->GetMapWorld();
m_ptLDownClient = point;
m_bLButtonDown = true;
pView->SetCapture();
//
// Convert to some odd coordinate space that the base tools code uses.
//
CPoint ptScreen = point;
ptScreen.x += pView->GetScrollPos(SB_HORZ);
ptScreen.y += pView->GetScrollPos(SB_VERT);
//
// Convert point to world coords.
//
pView->ClientToWorld(point);
Vector ptOrg( COORD_NOTINIT, COORD_NOTINIT, COORD_NOTINIT );
ptOrg[axHorz] = point.x;
ptOrg[axVert] = point.y;
// getvisiblepoint fills in any coord that's still set to COORD_NOTINIT:
pDoc->GetBestVisiblePoint(ptOrg);
// snap starting position to grid
if (!(GetAsyncKeyState(VK_MENU) & 0x8000))
{
pDoc->Snap(ptOrg);
}
BOOL bStarting = FALSE;
// if the tool is not empty, and shift is not held down (to
// start a new camera), don't do anything.
if(!IsEmpty())
{
if(!StartTranslation(ptScreen))
{
if (nFlags & MK_SHIFT)
{
SetEmpty();
bStarting = TRUE;
}
else
{
goto _DoNothing;
}
}
}
else
{
bStarting = TRUE;
}
SetClipObjects(pDoc->Selection_GetList());
if (bStarting)
{
StartNew(ptOrg);
pView->SetUpdateFlag(CMapView2D::updTool);
}
_DoNothing:
return true;
}
void CMapView::OnDraw(CDC* pDC)
{
CMapDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
int h = pDoc->GetHeight();
int w = pDoc->GetWidth();
CRect r;
pDC->GetClipBox(&r);
pDC->FillSolidRect(r, GetSysColor(COLOR_3DFACE));
if (w > 0 && h > 0)
{
// calculate the bounding box that is needed to be draw
CRect r;
pDC->GetClipBox(&r);
int ys = r.top / 40;
int ye = r.bottom / 40;
int xs = r.left / 40;
int xe = r.right / 40;
ye = min(ye+1,h);
xe = min(xe+1,w);
if (m_ViewMode == VIEW_MODE_GRAPHICS)
{
if (pDoc->m_pMapImage)
{
pDC->SetStretchBltMode(COLORONCOLOR);
CRect r(0,0,pDoc->m_pMapImage->GetWidth(), pDoc->m_pMapImage->GetHeight());
pDoc->m_pMapImage->Draw(pDC, r,r);
}
}
else
{
for (int y = ys; y < ye; y++)
{
for (int x = xs; x < xe; x++)
{
DrawMegaTile(pDC, x,y);
}
}
}
if (m_GridMode)
{
// draw major grid lines
{
CPen Pen;
Pen.CreateStockObject(BLACK_PEN);
CPen* pOldPen = pDC->SelectObject(&Pen);
for (int y = ys; y <= ye; y++)
{
pDC->MoveTo(xs*40,y*40);
pDC->LineTo(xe*40,y*40);
}
for (int x = xs; x <= xe; x++)
{
pDC->MoveTo(x*40,ys*40);
pDC->LineTo(x*40,ye*40);
}
pDC->SelectObject(pOldPen);
}
}
}
}
void CMapView::OnMouseMove(UINT, CPoint point)
{
if (m_HandDown && m_Tracking)
{
CPoint Delta = m_LastPoint - point;
CPoint NewPoint = GetScrollPosition() + Delta;
ScrollToPosition(NewPoint);
m_LastPoint = point;
}
else
{
point += GetScrollPosition();
int x = point.x / 40;
int y = point.y / 40;
int xe = (point.x % 40) / 10;
int ye = (point.y % 40) / 10;
CMapDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
int w = pDoc->GetWidth();
int h = pDoc->GetHeight();
CString str;
if (w > 0 && h > 0 && x >= 0 && y >= 0 && x < w && y < h && xe >= 0 && xe < 4 && ye >= 0 && ye < 4)
{
int r = y*w + x;
int e = ye*4 + xe;
CTile Tile = pDoc->GetTile(r);
int Elevation = Tile.Elevation;
CElement Element = g_App.m_Elements[Tile.E[e]];
str.Format("%s (%d)", Element.Name, Element.Type);
g_App.PrintStatus(str,1);
str.Format("%dm", Elevation);
g_App.PrintStatus(str,2);
str.Format("%d,%d (%d,%d)", x,y, xe,ye);
g_App.PrintStatus(str,3);
str.Format("%d E%d", r,e);
g_App.PrintStatus(str,4);
if (m_Tracking)
{
if (m_ViewMode == VIEW_MODE_ELEVATION)
{
pDoc->SetTileElevation(r, g_Elevation);
CString str;
str.Format("Change %d to %dm", r, g_Elevation);
g_App.PrintStatus(str);
CRect rect(CPoint(x*40, y*40), CSize(40,40));
rect.OffsetRect(-GetScrollPosition());
InvalidateRect(rect, FALSE);
}
else
{
pDoc->SetTile(r,e, g_Tile);
CString str;
str.Format("Change %d [%d] to %s", r,e, g_App.m_Elements[g_Tile].Name);
g_App.PrintStatus(str);
CRect rect(CPoint(x*40 + xe*10, y*40 + ye*10), CSize(10,10));
rect.OffsetRect(-GetScrollPosition());
InvalidateRect(rect, FALSE);
}
}
}
else
{
str.Empty();
g_App.PrintStatus(str,1);
g_App.PrintStatus(str,2);
g_App.PrintStatus(str,3);
g_App.PrintStatus(str,4);
}
str.Format("%d,%d", point.x,point.y);
g_App.PrintStatus(str,5,true);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pView -
// nFlags -
// point -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool Marker3D::OnMouseMove2D(CMapView2D *pView, UINT nFlags, CPoint point)
{
CMapDoc *pDoc = pView->GetDocument();
if (!pDoc)
{
return false;
}
bool bCursorSet = false;
unsigned int uConstraints = 0;
if ((GetAsyncKeyState(VK_MENU) & 0x8000))
{
uConstraints |= Tool3D::constrainNosnap;
}
//
// Make sure the point is visible.
//
if (m_bLButtonDown)
{
pView->ToolScrollToPoint(point);
}
//
// Convert to some odd coordinate space that the base tools code uses.
//
CPoint ptHitTest = point;
ptHitTest.x += pView->GetScrollPos(SB_HORZ);
ptHitTest.y += pView->GetScrollPos(SB_VERT);
//
// Convert to world coords.
//
Vector vecWorld;
pView->ClientToWorld(vecWorld, point);
point.x = vecWorld[axHorz];
point.y = vecWorld[axVert];
//
// Update status bar position display.
//
char szBuf[128];
m_pDocument->Snap(vecWorld);
sprintf(szBuf, " @%.0f, %.0f ", vecWorld[axHorz], vecWorld[axVert]);
SetStatusText(SBI_COORDS, szBuf);
//
// If we are currently dragging the marker, update that operation based on
// the current cursor position and keyboard state.
//
if (IsTranslating())
{
if (UpdateTranslation(point, uConstraints, CSize(0,0)))
{
pDoc->ToolUpdateViews(CMapView2D::updTool);
pDoc->Update3DViews();
}
// Don't change the cursor while dragging - it should remain a cross.
bCursorSet = true;
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_CROSS));
}
else if (!IsEmpty())
{
// Don't change the cursor while dragging - it should remain a cross.
bCursorSet = true;
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_CROSS));
}
if (!bCursorSet)
{
SetCursor(s_hcurEntity);
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: creates a new keyframe at the specified time
// Input : time -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
CMapEntity *CMapAnimator::CreateNewKeyFrame( float time )
{
// work out where we are in the animation
CMapKeyFrame *key;
CMapKeyFrame *pPrevKey;
float partialTime = GetKeyFramesAtTime( time, key, pPrevKey );
CMapEntity *pCurrentEnt = dynamic_cast<CMapEntity*>( key->Parent );
// check to see if we're direction on a key frame
Vector posOffset( 0, 0, 0 );
if ( partialTime == 0 )
{
// create this new key frame slightly after the current one, and offset
posOffset[0] = 64;
}
// get our orientation and position at this time
Vector vOrigin;
QAngle angles;
Quaternion qAngles;
GetAnimationAtTime( key, pPrevKey, partialTime, vOrigin, qAngles, m_iPositionInterpolator, m_iRotationInterpolator );
QuaternionAngles( qAngles, angles );
// create the new map entity
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
CMapWorld *pWorld = pDoc->GetMapWorld();
CMapEntity *pNewEntity = new CMapEntity;
Vector newPos;
VectorAdd( vOrigin, posOffset, newPos );
pNewEntity->SetPlaceholder( TRUE );
pNewEntity->SetOrigin( newPos );
pNewEntity->SetClass( "keyframe_track" );
char buf[128];
sprintf( buf, "%f %f %f", angles[0], angles[1], angles[2] );
pNewEntity->SetKeyValue( "angles", buf );
// link it into the keyframe list
// take over this existing next keyframe pointer
const char *nextKeyName = pCurrentEnt->GetKeyValue( "NextKey" );
if ( nextKeyName )
{
pNewEntity->SetKeyValue( "NextKey", nextKeyName );
}
// create a new unique name for this ent
char newName[128];
const char *oldName = pCurrentEnt->GetKeyValue( "targetname" );
if ( !oldName || oldName[0] == 0 )
oldName = "keyframe";
CMapEntity::GenerateNewTargetname( oldName, newName, 127 );
pNewEntity->SetKeyValue( "targetname", newName );
// point the current entity at the newly created one
pCurrentEnt->SetKeyValue( "NextKey", newName );
// copy any relevant values
const char *keyValue = pCurrentEnt->GetKeyValue( "parentname" );
if ( keyValue )
pNewEntity->SetKeyValue( "parentname", keyValue );
keyValue = pCurrentEnt->GetKeyValue( "MoveSpeed" );
if ( keyValue )
pNewEntity->SetKeyValue( "MoveSpeed", keyValue );
return(pNewEntity);
}
//-----------------------------------------------------------------------------
// Purpose: Called when they hit the Find, the Replace, or the Replace All button.
// Input : uCmd - The ID of the button the user hit, IDC_FIND_NEXT or IDC_REPLACE.
// Output : Returns TRUE to indicate that the message was handled.
//-----------------------------------------------------------------------------
BOOL CSearchReplaceDlg::OnFindReplace(UINT uCmd)
{
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if (!pDoc)
{
return TRUE;
}
static FindObject_t FindObject;
static CMapClass *pLastFound = NULL;
static nReplaceCount = 0;
bool bDone = false;
do
{
CMapClass *pObject = NULL;
if (m_bNewSearch)
{
//
// New search. Fetch the data from the controls.
//
UpdateData();
GetFindCriteria(FindObject, pDoc);
//
// We have to keep track of the last object in the iteration for replacement,
// because replacement is done when me advance to the next object.
//
pLastFound = NULL;
nReplaceCount = 0;
pObject = FindFirstObject(FindObject);
}
else
{
pObject = FindNextObject(FindObject);
}
//
// Replace All is undone as single operation. Mark the undo position the first time
// we find a match during a Replace All.
//
if (m_bNewSearch && (uCmd == IDC_REPLACE_ALL) && pObject)
{
GetHistory()->MarkUndoPosition(pDoc->Selection_GetList(), "Replace Text");
}
//
// If we have an object to do the replace on, do the replace.
//
if (pLastFound && ((uCmd == IDC_REPLACE) || (uCmd == IDC_REPLACE_ALL)))
{
if (uCmd == IDC_REPLACE)
{
// Allow for undo each time we do a Replace.
GetHistory()->MarkUndoPosition(NULL, "Replace Text");
}
//
// Do the replace on the last matching object we found. This lets the user see what
// object will be modified before it is done.
//
GetHistory()->Keep(pLastFound);
nReplaceCount += FindReplace((CMapEntity *)pLastFound, FindObject, m_strReplaceText);
GetDlgItem(IDCANCEL)->SetWindowText("Close");
}
if (pObject)
{
//
// We found an object that satisfies our search.
//
if ((uCmd == IDC_FIND_NEXT) || (uCmd == IDC_REPLACE))
{
//
// Highlight the match.
//
pDoc->SelectObject(pObject, CMapDoc::scClear | CMapDoc::scSelect);
pDoc->CenterSelection();
}
//
// Stop after one match unless we are doing a Replace All.
//
if (uCmd != IDC_REPLACE_ALL)
{
bDone = true;
}
m_bNewSearch = false;
pLastFound = pObject;
}
else
{
//
// No more objects in the search set match our criteria.
//
if ((m_bNewSearch) || (uCmd != IDC_REPLACE_ALL))
{
CString str;
str.Format("Finished searching for '%s'.", m_strFindText);
MessageBox(str, "Find/Replace Text", MB_OK);
// TODO: put the old selection back
}
else if (uCmd == IDC_REPLACE_ALL)
{
CString str;
str.Format("Replaced %d occurrences of the string '%s' with '%s'.", nReplaceCount, m_strFindText, m_strReplaceText);
MessageBox(str, "Find/Replace Text", MB_OK);
}
m_bNewSearch = true;
bDone = true;
}
} while (!bDone);
return TRUE;
}
//-----------------------------------------------------------------------------
// Purpose: Handles mouse move events in the 2D view.
// Input : Per CWnd::OnMouseMove.
// Output : Returns true if the message was handled, false if not.
//-----------------------------------------------------------------------------
bool Clipper3D::OnMouseMove2D(CMapView2D *pView, UINT nFlags, CPoint point)
{
CMapDoc *pDoc = pView->GetDocument();
if (!pDoc)
{
return false;
}
bool bCursorSet = false;
BOOL bDisableSnap = (GetAsyncKeyState(VK_MENU) & 0x8000) ? TRUE : FALSE;
//
// Make sure the point is visible.
//
if (m_bLButtonDown)
{
pView->ToolScrollToPoint(point);
}
//
// Convert to some odd coordinate space that the base tools code uses.
//
CPoint ptScreen = point;
ptScreen.x += pView->GetScrollPos(SB_HORZ);
ptScreen.y += pView->GetScrollPos(SB_VERT);
//
// Convert to world coords.
//
Vector vecWorld;
pView->ClientToWorld(vecWorld, point);
point.x = vecWorld[axHorz];
point.y = vecWorld[axVert];
//
// Update status bar position display.
//
char szBuf[128];
m_pDocument->Snap(vecWorld);
sprintf(szBuf, " @%.0f, %.0f ", vecWorld[axHorz], vecWorld[axVert]);
SetStatusText(SBI_COORDS, szBuf);
if (IsTranslating())
{
// cursor is cross here
bCursorSet = true;
UINT uConstraints = 0;
if (bDisableSnap)
{
uConstraints |= Tool3D::constrainNosnap;
}
if(nFlags & MK_CONTROL)
{
uConstraints |= Clipper3D::constrainMoveBoth;
}
if (UpdateTranslation(point, uConstraints, CSize(0,0)))
{
pDoc->ToolUpdateViews(CMapView2D::updTool);
pDoc->Update3DViews();
}
}
else if (!IsEmpty())
{
//
// If the cursor is on a handle, set it to a cross.
//
if (HitTest(ptScreen, TRUE) != -1)
{
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_CROSS));
bCursorSet = true;
}
}
if (!bCursorSet)
{
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
}
return true;
}
