988 lines
26 KiB
C++
988 lines
26 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "stdafx.h"
|
|
#include "GlobalFunctions.h"
|
|
#include "History.h"
|
|
#include "MapDefs.h"
|
|
#include "MapDoc.h"
|
|
#include "MapFace.h"
|
|
#include "MapSolid.h"
|
|
#include "MapView2D.h"
|
|
#include "MapWorld.h"
|
|
#include "Options.h"
|
|
#include "Render2D.h"
|
|
#include "Render3D.h"
|
|
#include "RenderUtils.h"
|
|
#include "StatusBarIDs.h" // dvs: remove
|
|
#include "ToolClipper.h"
|
|
#include "ToolManager.h"
|
|
#include "vgui/Cursor.h"
|
|
#include "Selection.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
|
|
#pragma warning( disable:4244 )
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
// Friend Function (for MapClass->EnumChildren Callback)
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This function creates a new clip group with the given solid as
|
|
// the original solid.
|
|
// Input: pSolid - the original solid to put in the clip list
|
|
// pClipper - the clipper tool
|
|
// Output: successful?? (true/false)
|
|
//-----------------------------------------------------------------------------
|
|
BOOL AddToClipList( CMapSolid *pSolid, Clipper3D *pClipper )
|
|
{
|
|
CClipGroup *pClipGroup = new CClipGroup;
|
|
if( !pClipGroup )
|
|
return false;
|
|
|
|
pClipGroup->SetOrigSolid( pSolid );
|
|
pClipper->m_ClipResults.AddToTail( pClipGroup );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
//
|
|
// CClipGroup
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor. Gets rid of the unnecessary clip solids.
|
|
//-----------------------------------------------------------------------------
|
|
CClipGroup::~CClipGroup()
|
|
{
|
|
delete m_pClipSolids[0];
|
|
delete m_pClipSolids[1];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: constructor - initialize the clipper variables
|
|
//-----------------------------------------------------------------------------
|
|
Clipper3D::Clipper3D(void)
|
|
{
|
|
m_Mode = FRONT;
|
|
|
|
m_ClipPlane.normal.Init();
|
|
m_ClipPlane.dist = 0.0f;
|
|
m_ClipPoints[0].Init();
|
|
m_ClipPoints[1].Init();
|
|
m_ClipPointHit = -1;
|
|
|
|
m_pOrigObjects = NULL;
|
|
|
|
m_bDrawMeasurements = false;
|
|
SetEmpty();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: deconstructor
|
|
//-----------------------------------------------------------------------------
|
|
Clipper3D::~Clipper3D(void)
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called when the tool is activated.
|
|
// Input : eOldTool - The ID of the previously active tool.
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::OnActivate()
|
|
{
|
|
if (IsActiveTool())
|
|
{
|
|
//
|
|
// Already the active tool - toggle the mode.
|
|
//
|
|
IterateClipMode();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called when the tool is deactivated.
|
|
// Input : eNewTool - The ID of the tool that is being activated.
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::OnDeactivate()
|
|
{
|
|
SetEmpty();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: (virtual imp) This function handles the "dragging" of the mouse
|
|
// while the left mouse button is depressed. It updates the position
|
|
// of the clippoing plane point selected in the StartTranslation
|
|
// function. This function rebuilds the clipping plane and updates
|
|
// the clipping solids when necessary.
|
|
// Input: pt - current location of the mouse in the 2DView
|
|
// uFlags - constrained clipping plane point movement
|
|
// *dragSize - not used in the virtual implementation
|
|
// Output: success of translation (TRUE/FALSE)
|
|
//-----------------------------------------------------------------------------
|
|
bool Clipper3D::UpdateTranslation( const Vector &vUpdate, UINT uFlags )
|
|
{
|
|
// sanity check
|
|
if( IsEmpty() )
|
|
return false;
|
|
|
|
Vector vNewPos = m_vOrgPos + vUpdate;
|
|
|
|
// snap point if need be
|
|
if ( uFlags & constrainSnap )
|
|
m_pDocument->Snap( vNewPos, uFlags );
|
|
|
|
//
|
|
// update clipping point positions
|
|
//
|
|
if ( m_ClipPoints[m_ClipPointHit] == vNewPos )
|
|
return false;
|
|
|
|
|
|
if( uFlags & constrainMoveAll )
|
|
{
|
|
//
|
|
// calculate the point and delta - to move both clip points simultaneously
|
|
//
|
|
|
|
Vector delta = vNewPos - m_ClipPoints[m_ClipPointHit];
|
|
m_ClipPoints[(m_ClipPointHit+1)%2] += delta;
|
|
}
|
|
|
|
m_ClipPoints[m_ClipPointHit] = vNewPos;
|
|
|
|
// build the new clip plane and update clip results
|
|
BuildClipPlane();
|
|
|
|
GetClipResults();
|
|
|
|
m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: (virtual imp) This function defines all finishing functionality
|
|
// necessary at the end of a clipping action. Nothing really!!!
|
|
// Input : bSave - passed along the the Tool finish translation call
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::FinishTranslation( bool bSave )
|
|
{
|
|
// get the clip results -- in case the update is a click and not a drag
|
|
GetClipResults();
|
|
|
|
Tool3D::FinishTranslation( bSave );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: iterate through the types of clipping modes, update after an
|
|
// iteration takes place to visualize the new clip results
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::IterateClipMode( void )
|
|
{
|
|
//
|
|
// increment the clipping mode (wrap when necessary)
|
|
//
|
|
m_Mode++;
|
|
|
|
if( m_Mode > BOTH )
|
|
{
|
|
m_Mode = FRONT;
|
|
}
|
|
|
|
// update the clipped objects based on the mode
|
|
GetClipResults();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This resets the solids to clip (the original list) and calls the
|
|
// CalcClipResults function to generate new "clip" solids
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::GetClipResults( void )
|
|
{
|
|
// reset the clip list to the original solid lsit
|
|
SetClipObjects( m_pOrigObjects );
|
|
|
|
// calculate the clipped objects based on the current "clip plane"
|
|
CalcClipResults();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This function allows one to specifically set the clipping plane
|
|
// information, as opposed to building a clip plane during "translation"
|
|
// Input: pPlane - the plane information used to create the clip plane
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::SetClipPlane( PLANE *pPlane )
|
|
{
|
|
//
|
|
// copy the clipping plane info
|
|
//
|
|
m_ClipPlane.normal = pPlane->normal;
|
|
m_ClipPlane.dist = pPlane->dist;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This function builds a clipping plane based on the clip point
|
|
// locations manipulated in the "translation" functions and the 2DView
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::BuildClipPlane( void )
|
|
{
|
|
// calculate the up vector
|
|
Vector upVect = m_vPlaneNormal;
|
|
|
|
// calculate the right vector
|
|
Vector rightVect;
|
|
VectorSubtract( m_ClipPoints[1], m_ClipPoints[0], rightVect );
|
|
|
|
// calculate the forward (normal) vector
|
|
Vector forwardVect;
|
|
CrossProduct( upVect, rightVect, forwardVect );
|
|
VectorNormalize( forwardVect );
|
|
|
|
//
|
|
// save the clip plane info
|
|
//
|
|
m_ClipPlane.normal = forwardVect;
|
|
m_ClipPlane.dist = DotProduct( m_ClipPoints[0], forwardVect );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This functions sets up the list of objects to be clipped.
|
|
// Initially the list is passed in (typically a Selection set). On
|
|
// subsequent "translation" updates the list is refreshed from the
|
|
// m_pOrigObjects list.
|
|
// Input: pList - the list of objects (solids) to be clipped
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::SetClipObjects( const CMapObjectList *pList )
|
|
{
|
|
// check for an empty list
|
|
if( !pList )
|
|
return;
|
|
|
|
// save the original list
|
|
m_pOrigObjects = pList;
|
|
|
|
// clear the clip results list
|
|
ResetClipResults();
|
|
|
|
//
|
|
// copy solids into the clip list
|
|
//
|
|
FOR_EACH_OBJ( *m_pOrigObjects, pos )
|
|
{
|
|
CMapClass *pObject = m_pOrigObjects->Element( pos );
|
|
if( !pObject )
|
|
continue;
|
|
|
|
if( pObject->IsMapClass( MAPCLASS_TYPE( CMapSolid ) ) )
|
|
{
|
|
AddToClipList( ( CMapSolid* )pObject, this );
|
|
}
|
|
|
|
pObject->EnumChildren( ENUMMAPCHILDRENPROC( AddToClipList ), DWORD( this ), MAPCLASS_TYPE( CMapSolid ) );
|
|
}
|
|
|
|
// the clipping list is not empty anymore
|
|
m_bEmpty = false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This function calculates based on the defined or given clipping
|
|
// plane and clipping mode the new clip solids.
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::CalcClipResults( void )
|
|
{
|
|
// sanity check
|
|
if( IsEmpty() )
|
|
return;
|
|
|
|
//
|
|
// iterate through and clip all of the solids in the clip list
|
|
//
|
|
FOR_EACH_OBJ( m_ClipResults, pos )
|
|
{
|
|
CClipGroup *pClipGroup = m_ClipResults.Element( pos );
|
|
CMapSolid *pOrigSolid = pClipGroup->GetOrigSolid();
|
|
if( !pOrigSolid )
|
|
continue;
|
|
|
|
//
|
|
// check the modes for which solids to generate
|
|
//
|
|
CMapSolid *pFront = NULL;
|
|
CMapSolid *pBack = NULL;
|
|
if( m_Mode == FRONT )
|
|
{
|
|
pOrigSolid->Split( &m_ClipPlane, &pFront, NULL );
|
|
}
|
|
else if( m_Mode == BACK )
|
|
{
|
|
pOrigSolid->Split( &m_ClipPlane, NULL, &pBack );
|
|
}
|
|
else if( m_Mode == BOTH )
|
|
{
|
|
pOrigSolid->Split( &m_ClipPlane, &pFront, &pBack );
|
|
}
|
|
|
|
if( pFront )
|
|
{
|
|
pFront->SetTemporary(true);
|
|
pClipGroup->SetClipSolid( pFront, FRONT );
|
|
}
|
|
|
|
if( pBack )
|
|
{
|
|
pBack->SetTemporary(true);
|
|
pClipGroup->SetClipSolid( pBack, BACK );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This function handles the removal of the "original" solid when it
|
|
// has been clipped into new solid(s) or removed from the world (group
|
|
// or entity) entirely. It handles this in an undo safe fashion.
|
|
// Input: pOrigSolid - the solid to remove
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::RemoveOrigSolid( CMapSolid *pOrigSolid )
|
|
{
|
|
m_pDocument->DeleteObject(pOrigSolid);
|
|
|
|
//
|
|
// remove the solid from the selection set if in the seleciton set and
|
|
// its parent is the world, or set the selection state to none parent is group
|
|
// or entity in the selection set
|
|
//
|
|
|
|
CSelection *pSelection = m_pDocument->GetSelection();
|
|
|
|
if ( pSelection->IsSelected( pOrigSolid ) )
|
|
{
|
|
pSelection->SelectObject( pOrigSolid, scUnselect );
|
|
}
|
|
else
|
|
{
|
|
pOrigSolid->SetSelectionState( SELECT_NONE );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This function handles the saving of newly clipped solids (derived
|
|
// from an "original" solid). It handles them in an undo safe fashion.
|
|
// Input: pSolid - the newly clipped solid
|
|
// pOrigSolid - the "original" solid or solid the clipped solid was
|
|
// derived from
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::SaveClipSolid( CMapSolid *pSolid, CMapSolid *pOrigSolid )
|
|
{
|
|
//
|
|
// no longer a temporary solid
|
|
//
|
|
pSolid->SetTemporary( FALSE );
|
|
|
|
//
|
|
// Add the new solid to the original solid's parent (group, entity, world, etc.).
|
|
//
|
|
m_pDocument->AddObjectToWorld(pSolid, pOrigSolid->GetParent());
|
|
|
|
//
|
|
// handle linking solid into selection -- via selection set when parent is the world
|
|
// and selected, or set the selection state if parent is group or entity in selection set
|
|
//
|
|
if( m_pDocument->GetSelection()->IsSelected( pOrigSolid ) )
|
|
{
|
|
m_pDocument->SelectObject( pSolid, scSelect );
|
|
}
|
|
else
|
|
{
|
|
pSolid->SetSelectionState( SELECT_NORMAL );
|
|
}
|
|
|
|
GetHistory()->KeepNew( pSolid );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This function saves all the clipped solid information. If new solids
|
|
// were generated from the original, they are saved and the original is
|
|
// set for desctruciton. Otherwise, the original solid is kept.
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::SaveClipResults( void )
|
|
{
|
|
// sanity check!
|
|
if( IsEmpty() )
|
|
return;
|
|
|
|
// mark this place in the history
|
|
GetHistory()->MarkUndoPosition( NULL, "Clip Objects" );
|
|
|
|
//
|
|
// save all new objects into the selection list
|
|
//
|
|
FOR_EACH_OBJ( m_ClipResults, pos )
|
|
{
|
|
CClipGroup *pClipGroup = m_ClipResults.Element( pos );
|
|
if( !pClipGroup )
|
|
continue;
|
|
|
|
CMapSolid *pOrigSolid = pClipGroup->GetOrigSolid();
|
|
CMapSolid *pBackSolid = pClipGroup->GetClipSolid( CClipGroup::BACK );
|
|
CMapSolid *pFrontSolid = pClipGroup->GetClipSolid( CClipGroup::FRONT );
|
|
|
|
//
|
|
// save the front clip solid and clear the clip results list of itself
|
|
//
|
|
if( pFrontSolid )
|
|
{
|
|
SaveClipSolid( pFrontSolid, pOrigSolid );
|
|
pClipGroup->SetClipSolid( NULL, CClipGroup::FRONT );
|
|
}
|
|
|
|
//
|
|
// save the front clip solid and clear the clip results list of itself
|
|
//
|
|
if( pBackSolid )
|
|
{
|
|
SaveClipSolid( pBackSolid, pOrigSolid );
|
|
pClipGroup->SetClipSolid( NULL, CClipGroup::BACK );
|
|
}
|
|
|
|
// Send the notification that this solid as been clipped.
|
|
pOrigSolid->PostUpdate( Notify_Clipped );
|
|
|
|
// remove the original solid
|
|
RemoveOrigSolid( pOrigSolid );
|
|
}
|
|
|
|
// set the the clipping results list as empty
|
|
ResetClipResults();
|
|
|
|
// update world and views
|
|
|
|
m_pDocument->SetModifiedFlag();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draws the measurements of a brush in the 2D view.
|
|
// Input : pRender -
|
|
// pSolid -
|
|
// nFlags -
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::DrawBrushExtents( CRender2D *pRender, CMapSolid *pSolid, int nFlags )
|
|
{
|
|
//
|
|
// get the bounds of the solid
|
|
//
|
|
Vector Mins, Maxs;
|
|
pSolid->GetRender2DBox( Mins, Maxs );
|
|
|
|
//
|
|
// Determine which side of the clipping plane this solid is on in screen
|
|
// space. This tells us where to draw the extents.
|
|
//
|
|
if( ( m_ClipPlane.normal[0] == 0 ) && ( m_ClipPlane.normal[1] == 0 ) && ( m_ClipPlane.normal[2] == 0 ) )
|
|
return;
|
|
|
|
Vector normal = m_ClipPlane.normal;
|
|
|
|
if( nFlags & DBT_BACK )
|
|
{
|
|
VectorNegate( normal );
|
|
}
|
|
|
|
Vector2D planeNormal;
|
|
|
|
pRender->TransformNormal( planeNormal, normal );
|
|
|
|
if( planeNormal.x <= 0 )
|
|
{
|
|
nFlags &= ~DBT_RIGHT;
|
|
nFlags |= DBT_LEFT;
|
|
}
|
|
else if( planeNormal.x > 0 )
|
|
{
|
|
nFlags &= ~DBT_LEFT;
|
|
nFlags |= DBT_RIGHT;
|
|
}
|
|
|
|
if( planeNormal.y <= 0 )
|
|
{
|
|
nFlags &= ~DBT_BOTTOM;
|
|
nFlags |= DBT_TOP;
|
|
}
|
|
else if( planeNormal.y > 0 )
|
|
{
|
|
nFlags &= ~DBT_TOP;
|
|
nFlags |= DBT_BOTTOM;
|
|
}
|
|
|
|
DrawBoundsText(pRender, Mins, Maxs, nFlags);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pRender -
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::RenderTool2D(CRender2D *pRender)
|
|
{
|
|
if ( IsEmpty() )
|
|
return;
|
|
|
|
// check flag for rendering vertices
|
|
bool bDrawVerts = ( bool )( Options.view2d.bDrawVertices == TRUE );
|
|
|
|
// setup the line to use
|
|
|
|
pRender->SetDrawColor( 255, 255, 255 );
|
|
|
|
//
|
|
// render the clipped solids
|
|
//
|
|
FOR_EACH_OBJ( m_ClipResults, pos )
|
|
{
|
|
CClipGroup *pClipGroup = m_ClipResults.Element( pos );
|
|
CMapSolid *pClipBack = pClipGroup->GetClipSolid( CClipGroup::BACK );
|
|
CMapSolid *pClipFront = pClipGroup->GetClipSolid( CClipGroup::FRONT );
|
|
if( !pClipBack && !pClipFront )
|
|
continue;
|
|
|
|
//
|
|
// draw clip solids with the extents
|
|
//
|
|
if( pClipBack )
|
|
{
|
|
int faceCount = pClipBack->GetFaceCount();
|
|
for( int i = 0; i < faceCount; i++ )
|
|
{
|
|
CMapFace *pFace = pClipBack->GetFace( i );
|
|
|
|
// size 4
|
|
pRender->DrawPolyLine( pFace->nPoints, pFace->Points );
|
|
|
|
if ( bDrawVerts )
|
|
{
|
|
pRender->DrawHandles( pFace->nPoints, pFace->Points );
|
|
}
|
|
|
|
if( m_bDrawMeasurements )
|
|
{
|
|
DrawBrushExtents( pRender, pClipBack, DBT_TOP | DBT_LEFT | DBT_BACK );
|
|
}
|
|
}
|
|
}
|
|
|
|
if( pClipFront )
|
|
{
|
|
int faceCount = pClipFront->GetFaceCount();
|
|
for( int i = 0; i < faceCount; i++ )
|
|
{
|
|
CMapFace *pFace = pClipFront->GetFace( i );
|
|
|
|
pRender->DrawPolyLine( pFace->nPoints, pFace->Points );
|
|
|
|
if ( bDrawVerts )
|
|
{
|
|
pRender->DrawHandles( pFace->nPoints, pFace->Points );
|
|
}
|
|
|
|
if( m_bDrawMeasurements )
|
|
{
|
|
DrawBrushExtents( pRender, pClipFront, DBT_BOTTOM | DBT_RIGHT );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// draw the clip-plane
|
|
//
|
|
pRender->SetDrawColor( 0, 255, 255 );
|
|
pRender->DrawLine( m_ClipPoints[0], m_ClipPoints[1] );
|
|
|
|
//
|
|
// draw the clip-plane endpoints
|
|
//
|
|
|
|
pRender->SetHandleStyle( HANDLE_RADIUS, CRender::HANDLE_SQUARE );
|
|
pRender->SetHandleColor( 255, 255, 255 );
|
|
|
|
pRender->DrawHandle( m_ClipPoints[0] );
|
|
pRender->DrawHandle( m_ClipPoints[1] );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Renders the brushes that will be left by the clipper in white
|
|
// wireframe.
|
|
// Input : pRender - Rendering interface.
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::RenderTool3D( CRender3D *pRender )
|
|
{
|
|
// is there anything to render?
|
|
if( m_bEmpty )
|
|
return;
|
|
|
|
//
|
|
// setup the renderer
|
|
//
|
|
pRender->PushRenderMode( RENDER_MODE_WIREFRAME );
|
|
|
|
FOR_EACH_OBJ( m_ClipResults, pos )
|
|
{
|
|
CClipGroup *pClipGroup = m_ClipResults.Element( pos );
|
|
|
|
CMapSolid *pFrontSolid = pClipGroup->GetClipSolid( CClipGroup::FRONT );
|
|
if( pFrontSolid )
|
|
{
|
|
color32 rgbColor = pFrontSolid->GetRenderColor();
|
|
pFrontSolid->SetRenderColor(255, 255, 255);
|
|
pFrontSolid->Render3D(pRender);
|
|
pFrontSolid->SetRenderColor(rgbColor);
|
|
}
|
|
|
|
CMapSolid *pBackSolid = pClipGroup->GetClipSolid( CClipGroup::BACK );
|
|
if( pBackSolid )
|
|
{
|
|
color32 rgbColor = pBackSolid->GetRenderColor();
|
|
pBackSolid->SetRenderColor(255, 255, 255);
|
|
pBackSolid->Render3D(pRender);
|
|
pBackSolid->SetRenderColor(rgbColor);
|
|
}
|
|
}
|
|
|
|
pRender->PopRenderMode();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: (virtual imp)
|
|
// Input : pt -
|
|
// BOOL -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int Clipper3D::HitTest(CMapView *pView, const Vector2D &ptClient, bool bTestHandles)
|
|
{
|
|
// check points
|
|
|
|
for ( int i=0; i<2;i++ )
|
|
{
|
|
if ( HitRect(pView, ptClient, m_ClipPoints[i], HANDLE_RADIUS) )
|
|
{
|
|
return i+1; // return clip point index + 1
|
|
}
|
|
}
|
|
|
|
// neither point hit
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Reset (clear) the clip results.
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::ResetClipResults( void )
|
|
{
|
|
//
|
|
// delete the clip solids held in the list -- originals are just pointers
|
|
// to pre-existing objects
|
|
//
|
|
FOR_EACH_OBJ( m_ClipResults, pos )
|
|
{
|
|
CClipGroup *pClipGroup = m_ClipResults.Element(pos);
|
|
|
|
if( pClipGroup )
|
|
{
|
|
delete pClipGroup;
|
|
}
|
|
}
|
|
|
|
m_ClipResults.RemoveAll();
|
|
|
|
// the clipping list is empty
|
|
SetEmpty();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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();
|
|
return true;
|
|
}
|
|
|
|
case VK_RETURN:
|
|
{
|
|
//
|
|
// Do the clip.
|
|
//
|
|
if (!IsEmpty() )
|
|
{
|
|
SaveClipResults();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
case VK_ESCAPE:
|
|
{
|
|
OnEscape();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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, const Vector2D &vPoint)
|
|
{
|
|
Tool3D::OnLMouseDown2D(pView, nFlags, vPoint);
|
|
|
|
unsigned int uConstraints = GetConstraints( nFlags );
|
|
|
|
//
|
|
// Convert point to world coords.
|
|
//
|
|
Vector vecWorld;
|
|
pView->ClientToWorld(vecWorld, vPoint);
|
|
vecWorld[pView->axThird] = COORD_NOTINIT;
|
|
|
|
// getvisiblepoint fills in any coord that's still set to COORD_NOTINIT:
|
|
m_pDocument->GetBestVisiblePoint(vecWorld);
|
|
|
|
// snap starting position to grid
|
|
if ( uConstraints & constrainSnap )
|
|
m_pDocument->Snap(vecWorld, uConstraints);
|
|
|
|
|
|
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())
|
|
{
|
|
// test for clip point hit (result = {0, 1, 2}
|
|
int hitPoint = HitTest( pView, vPoint );
|
|
|
|
if ( hitPoint > 0 )
|
|
{
|
|
// test for clip point hit (result = {0, 1, -1})
|
|
m_ClipPointHit = hitPoint-1; // convert back to index
|
|
m_vOrgPos = m_ClipPoints[m_ClipPointHit];
|
|
StartTranslation( pView, vPoint );
|
|
}
|
|
else if ( m_vPlaneNormal != pView->GetViewAxis() )
|
|
{
|
|
SetEmpty();
|
|
bStarting = true;
|
|
}
|
|
else
|
|
{
|
|
if (nFlags & MK_SHIFT)
|
|
{
|
|
SetEmpty();
|
|
bStarting = true;
|
|
}
|
|
else
|
|
{
|
|
return true; // do nothing;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bStarting = true;
|
|
}
|
|
|
|
SetClipObjects(m_pDocument->GetSelection()->GetList());
|
|
|
|
if (bStarting)
|
|
{
|
|
// start the tools translation functionality
|
|
StartTranslation( pView, vPoint );
|
|
|
|
// set the initial clip points
|
|
m_ClipPointHit = 0;
|
|
m_ClipPoints[0] = vecWorld;
|
|
m_ClipPoints[1] = vecWorld;
|
|
m_vOrgPos = vecWorld;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handles left mouse button up events in the 2D view.
|
|
// Input : Per CWnd::OnLButtonUp.
|
|
// Output : Returns true if the message was handled, false if not.
|
|
//-----------------------------------------------------------------------------
|
|
bool Clipper3D::OnLMouseUp2D(CMapView2D *pView, UINT nFlags, const Vector2D &vPoint)
|
|
{
|
|
Tool3D::OnLMouseUp2D(pView, nFlags, vPoint);
|
|
|
|
if ( IsTranslating() )
|
|
{
|
|
FinishTranslation(true);
|
|
}
|
|
|
|
m_pDocument->UpdateStatusbar();
|
|
|
|
return true;
|
|
}
|
|
|
|
unsigned int Clipper3D::GetConstraints(unsigned int nKeyFlags)
|
|
{
|
|
unsigned int uConstraints = Tool3D::GetConstraints( nKeyFlags );
|
|
|
|
if(nKeyFlags & MK_CONTROL)
|
|
{
|
|
uConstraints |= constrainMoveAll;
|
|
}
|
|
|
|
return uConstraints;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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, const Vector2D &vPoint)
|
|
{
|
|
vgui::HCursor hCursor = vgui::dc_arrow;
|
|
unsigned int uConstraints = GetConstraints( nFlags );
|
|
|
|
Tool3D::OnMouseMove2D(pView, nFlags, vPoint);
|
|
|
|
//
|
|
// Convert to world coords.
|
|
//
|
|
Vector vecWorld;
|
|
pView->ClientToWorld(vecWorld, vPoint);
|
|
|
|
//
|
|
// Update status bar position display.
|
|
//
|
|
char szBuf[128];
|
|
|
|
if ( uConstraints & constrainSnap )
|
|
m_pDocument->Snap(vecWorld,uConstraints);
|
|
|
|
sprintf(szBuf, " @%.0f, %.0f ", vecWorld[pView->axHorz], vecWorld[pView->axVert]);
|
|
SetStatusText(SBI_COORDS, szBuf);
|
|
|
|
if (IsTranslating())
|
|
{
|
|
// cursor is cross here
|
|
Tool3D::UpdateTranslation( pView, vPoint, uConstraints);
|
|
|
|
hCursor = vgui::dc_none;
|
|
}
|
|
else if (!IsEmpty())
|
|
{
|
|
//
|
|
// If the cursor is on a handle, set it to a cross.
|
|
//
|
|
if (HitTest( pView, vPoint, true))
|
|
{
|
|
hCursor = vgui::dc_crosshair;
|
|
}
|
|
}
|
|
|
|
if ( hCursor != vgui::dc_none )
|
|
pView->SetCursor( hCursor );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handles character events.
|
|
// Input : Per CWnd::OnKeyDown.
|
|
// Output : Returns true if the message was handled, false if not.
|
|
//-----------------------------------------------------------------------------
|
|
bool Clipper3D::OnKeyDown3D(CMapView3D *pView, UINT nChar, UINT nRepCnt, UINT nFlags)
|
|
{
|
|
switch (nChar)
|
|
{
|
|
case VK_RETURN:
|
|
{
|
|
if (!IsEmpty()) // dvs: what does isempty mean for the clipper?
|
|
{
|
|
SaveClipResults();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
case VK_ESCAPE:
|
|
{
|
|
OnEscape();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handles the escape key in the 2D or 3D views.
|
|
//-----------------------------------------------------------------------------
|
|
void Clipper3D::OnEscape(void)
|
|
{
|
|
// If we're clipping, clear it
|
|
if (!IsEmpty())
|
|
{
|
|
SetEmpty();
|
|
}
|
|
else
|
|
{
|
|
m_pDocument->GetTools()->SetTool(TOOL_POINTER);
|
|
}
|
|
}
|
|
|