Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1564 lines
40 KiB

5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include <stdafx.h>
#include "hammer.h"
#include "ToolDisplace.h"
#include "MainFrm.h"
#include "FaceEditSheet.h"
#include "GlobalFunctions.h"
#include "MapAtom.h"
#include "MapSolid.h"
#include "MapView3D.h"
#include "History.h"
#include "Camera.h"
#include "MapDoc.h"
#include "ChunkFile.h"
#include "ToolManager.h"
#include "SculptOptions.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
//=============================================================================
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CToolDisplace::CToolDisplace()
{
m_uiTool = DISPTOOL_SELECT;
m_uiEffect = DISPPAINT_EFFECT_RAISELOWER;
m_uiBrushType = DISPPAINT_BRUSHTYPE_SOFT;
m_iPaintChannel = DISPPAINT_CHANNEL_POSITION;
m_flPaintValueGeo = 5.0f;
m_flPaintValueData = 25.0f;
m_iPaintAxis = DISPPAINT_AXIS_FACE;
m_vecPaintAxis.Init( 0.0f, 0.0f, 1.0f );
m_bAutoSew = false;
m_bSpatial = false;
m_flSpatialRadius = 15.0f;
m_bSpatialRadius = false;
m_bSelectMaskTool = true;
m_bGridMaskTool = false;
m_bLMBDown = false;
m_bRMBDown = false;
m_bNudge = false;
m_bNudgeInit = false;
m_EditDispHandle = EDITDISPHANDLE_INVALID;
// load filters from file
static char szProgramDir[MAX_PATH];
APP()->GetDirectory( DIR_PROGRAM, szProgramDir );
strcat( szProgramDir, "filters\\dispfilters.txt" );
LoadFilters( szProgramDir );
AddFiltersToManagers();
m_SculptTool = NULL;
m_MousePoint.Init( 0.0f, 0.0f );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CToolDisplace::~CToolDisplace()
{
// destroy filters
m_FilterRaiseLowerMgr.Destroy();
m_FilterRaiseToMgr.Destroy();
m_FilterSmoothMgr.Destroy();
}
//-----------------------------------------------------------------------------
// Purpose: Called when the tool is activated.
// Input : eOldTool - The ID of the previously active tool.
//-----------------------------------------------------------------------------
void CToolDisplace::OnActivate()
{
//
// initialize masks
//
CMapDisp::SetSelectMask( m_bSelectMaskTool );
CMapDisp::SetGridMask( m_bGridMaskTool );
}
//-----------------------------------------------------------------------------
// Purpose: Called when the tool is deactivated.
// Input : eNewTool - The ID of the tool that is being activated.
//-----------------------------------------------------------------------------
void CToolDisplace::OnDeactivate()
{
//
// reset masks
//
CMapDisp::SetSelectMask( false );
CMapDisp::SetGridMask( false );
if ( m_pDocument->GetTools()->GetActiveToolID() != TOOL_FACEEDIT_MATERIAL )
{
// Clear the selected faces when we are deactivated.
m_pDocument->SelectFace(NULL, 0, scClear );
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CToolDisplace::UpdateMapViews( CMapView3D *pView )
{
CMapDoc *pDoc = pView->GetMapDoc();
if( pDoc )
{
pDoc->SetModifiedFlag();
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void CToolDisplace::CalcViewCenter( CMapView3D *pView )
{
CRect windowRect;
pView->GetWindowRect( windowRect );
m_viewCenter = windowRect.CenterPoint();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::OnLMouseDown3D( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
// Set down flags
m_bLMBDown = true;
if( m_uiTool == DISPTOOL_PAINT_SCULPT )
{
m_SculptTool->OnLMouseDown3D( pView, nFlags, vPoint );
m_SculptTool->BeginPaint( pView, vPoint );
ApplySculptSpatialPaintTool( pView, nFlags, vPoint );
// update
UpdateMapViews( pView );
return true;
}
// Selection.
if( m_uiTool == DISPTOOL_SELECT || ( GetAsyncKeyState( VK_CONTROL ) & 0x8000 ) )
{
// handle selection at point
HandleSelection( pView, vPoint );
// update
UpdateMapViews( pView );
return true;
}
// Tagging.
if ( m_uiTool == DISPTOOL_TAG_WALKABLE || m_uiTool == DISPTOOL_TAG_BUILDABLE || m_uiTool == DISPTOOL_TAG_REMOVE )
{
// Do tagging.
HandleTagging( pView, vPoint );
return true;
}
// Resize the spatial painting sphere.
if( ( m_uiTool == DISPTOOL_PAINT ) && ( IsSpatialPainting() ) &&
( GetAsyncKeyState( VK_MENU ) & 0x8000 ) )
{
ResizeSpatialRadius_Activate( pView );
return true;
}
// Nudging.
if( ( m_uiTool == DISPTOOL_PAINT ) && ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 ) )
{
// is the current effect raise/lower (nudge only works in raise/lower mode)
if( m_uiEffect == DISPPAINT_EFFECT_RAISELOWER )
{
EditDispHandle_t handle = GetHitPos( pView, vPoint );
if( handle != EDITDISPHANDLE_INVALID )
{
m_EditDispHandle = handle;
Nudge_Activate( pView, handle );
UpdateMapViews( pView );
return true;
}
}
}
// Painting.
if( m_uiTool == DISPTOOL_PAINT )
{
// get hit info
EditDispHandle_t handle = GetHitPos( pView, vPoint );
if( handle == EDITDISPHANDLE_INVALID )
return false;
m_EditDispHandle = handle;
CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
if( !pDispMgr )
return false;
pDispMgr->PreUndo( "Displacement Modifier" );
// Paint using the correct mode.
if ( m_bSpatial )
{
int nDispCount = pDispMgr->SelectCount();
for ( int iDisp = 0; iDisp < nDispCount; iDisp++ )
{
CMapDisp *pDispSelect = pDispMgr->GetFromSelect( iDisp );
if ( pDispSelect )
{
pDispSelect->Paint_Init( DISPPAINT_CHANNEL_POSITION );
}
}
// setup for undo - modifying the displacement (painting)
ApplySpatialPaintTool( nFlags, vPoint, pDisp );
}
else
{
// setup for undo - modifying the displacement (painting)
pDispMgr->Undo( handle, true );
pDisp = EditDispMgr()->GetDisp( handle );
ApplyPaintTool( nFlags, vPoint, pDisp );
}
// update
UpdateMapViews( pView );
}
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::OnLMouseUp3D( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
// left button up
m_bLMBDown = false;
if( m_uiTool == DISPTOOL_PAINT_SCULPT )
{
m_SculptTool->OnLMouseUp3D( pView, nFlags, vPoint );
return true;
}
if ( m_bNudge )
{
Nudge_Deactivate();
}
if ( m_bSpatialRadius )
{
ResizeSpatialRadius_Deactivate();
}
IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
if( pDispMgr )
{
pDispMgr->PostUndo();
}
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::OnRMouseDown3D( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
// left button down
m_bRMBDown = true;
if( m_uiTool == DISPTOOL_PAINT_SCULPT )
{
m_SculptTool->OnRMouseDown3D( pView, nFlags, vPoint );
m_SculptTool->BeginPaint( pView, vPoint );
ApplySculptSpatialPaintTool( pView, nFlags, vPoint );
// update
UpdateMapViews( pView );
return true;
}
//
// lifting the face normal - painting with the axis set to "Face Normal"
//
if( ( m_uiTool == DISPTOOL_PAINT ) && ( m_iPaintAxis == DISPPAINT_AXIS_FACE ) &&
( GetAsyncKeyState( VK_MENU ) & 0x8000 ) )
{
LiftFaceNormal( pView, vPoint );
return true;
}
// Tagging.
if ( m_uiTool == DISPTOOL_TAG_WALKABLE || m_uiTool == DISPTOOL_TAG_BUILDABLE || m_uiTool == DISPTOOL_TAG_REMOVE )
{
// Do tagging.
HandleTaggingReset( pView, vPoint );
return true;
}
//
// handle the normal paint procedure
//
if( m_uiTool == DISPTOOL_PAINT )
{
// get hit info
EditDispHandle_t handle = GetHitPos( pView, vPoint );
if( handle == EDITDISPHANDLE_INVALID )
return false;
m_EditDispHandle = handle;
CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
if( !pDispMgr )
return false;
pDispMgr->PreUndo( "Displacement Modifier" );
// apply the current displacement tool
if ( m_bSpatial )
{
int nDispCount = pDispMgr->SelectCount();
for ( int iDisp = 0; iDisp < nDispCount; iDisp++ )
{
CMapDisp *pDispSelect = pDispMgr->GetFromSelect( iDisp );
if ( pDispSelect )
{
pDispSelect->Paint_Init( DISPPAINT_CHANNEL_POSITION );
}
}
ApplySpatialPaintTool( nFlags, vPoint, pDisp );
}
else
{
// setup for undo
pDispMgr->Undo( handle, true );
pDisp = EditDispMgr()->GetDisp( handle );
ApplyPaintTool( nFlags, vPoint, pDisp );
}
// update
UpdateMapViews( pView );
}
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::OnRMouseUp3D( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
// left button up
m_bRMBDown = false;
if( m_uiTool == DISPTOOL_PAINT_SCULPT )
{
m_SculptTool->OnRMouseUp3D( pView, nFlags, vPoint );
return true;
}
IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
if( pDispMgr )
{
pDispMgr->PostUndo();
}
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::OnMouseMove3D( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
m_MousePoint = vPoint;
if( m_uiTool == DISPTOOL_PAINT_SCULPT )
{
m_SculptTool->OnMouseMove3D( pView, nFlags, vPoint );
if( ( m_bLMBDown || m_bRMBDown ) )
{
ApplySculptSpatialPaintTool( pView, nFlags, vPoint );
}
// update
UpdateMapViews( pView );
return true;
}
// nudging
if ( ( m_uiTool == DISPTOOL_PAINT ) && ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 ) &&
m_bLMBDown && m_bNudge )
{
Nudge_Do();
}
// Resizing the spatial sphere.
else if ( ( m_uiTool == DISPTOOL_PAINT ) && ( GetAsyncKeyState( VK_MENU ) & 0x8000 ) &&
m_bLMBDown && m_bSpatialRadius )
{
ResizeSpatialRadius_Do();
}
// painting
else
{
// get hit info
EditDispHandle_t handle = GetHitPos( pView, vPoint );
if( handle == EDITDISPHANDLE_INVALID )
return false;
m_EditDispHandle = handle;
CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
//
// continue with tool operation?!
//
if( ( m_bLMBDown || m_bRMBDown ) && !( GetAsyncKeyState( VK_CONTROL ) & 0x8000 ) &&
( m_uiTool == DISPTOOL_PAINT ) )
{
if ( m_bSpatial )
{
ApplySpatialPaintTool( nFlags, vPoint, pDisp );
}
else
{
ApplyPaintTool( nFlags, vPoint, pDisp );
}
}
// not nudging anymore -- if we were
if( m_bNudge )
{
Nudge_Deactivate();
}
if ( m_bSpatialRadius )
{
ResizeSpatialRadius_Deactivate();
}
}
// update
UpdateMapViews( pView );
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::LiftFaceNormal( CMapView3D *pView, const Vector2D &vPoint )
{
//
// check for closest solid object
//
ULONG ulFace;
CMapClass *pObject;
if( ( ( pObject = pView->NearestObjectAt( vPoint, ulFace ) ) != NULL ) )
{
if( pObject->IsMapClass( MAPCLASS_TYPE( CMapSolid ) ) )
{
// get the solid
CMapSolid *pSolid = ( CMapSolid* )pObject;
if( !pSolid )
return;
// trace a line and get the normal -- will get a displacement normal
// if one exists
CMapFace *pFace = pSolid->GetFace( ulFace );
if( !pFace )
return;
Vector vRayStart, vRayEnd;
pView->GetCamera()->BuildRay( vPoint, vRayStart, vRayEnd );
Vector vHitPos, vHitNormal;
if( pFace->TraceLine( vHitPos, vHitNormal, vRayStart, vRayEnd ) )
{
// set the paint direction
m_vecPaintAxis = vHitNormal;
}
else
{
// will default to z if no normal found
m_vecPaintAxis.Init( 0.0f, 0.0f, 1.0f );
}
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::Nudge_Activate( CMapView3D *pView, EditDispHandle_t dispHandle )
{
IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
if( !pDispMgr )
return;
pDispMgr->PreUndo( "Displacement Nudge" );
// Setup paint (nudge) using the correct mode.
if ( m_bSpatial )
{
int nDispCount = pDispMgr->SelectCount();
for ( int iDisp = 0; iDisp < nDispCount; iDisp++ )
{
CMapDisp *pDisp = pDispMgr->GetFromSelect( iDisp );
if ( pDisp )
{
pDisp->Paint_Init( DISPPAINT_CHANNEL_POSITION );
}
}
}
else
{
// setup for undo
pDispMgr->Undo( dispHandle, true );
}
// setup the cursor for "nudging"
CalcViewCenter( pView );
SetCursorPos( m_viewCenter.x, m_viewCenter.y );
pView->SetCapture();
// set nudging
m_bNudge = true;
m_bNudgeInit = true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::Nudge_Deactivate( void )
{
ReleaseCapture();
m_bNudge = false;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::Nudge_Do( void )
{
CMapDisp *pNudgeDisp = GetEditDisp();
if (pNudgeDisp == NULL)
{
return;
}
//
// find the greatest delta and "nudge"
//
// NOTE: using get cursor position, because it is different than the
// "point" incoming into mouse move????
//
CPoint nudgePos;
GetCursorPos( &nudgePos );
CPoint nudgeDelta;
nudgeDelta.x = nudgePos.x - m_viewCenter.x;
nudgeDelta.y = nudgePos.y - m_viewCenter.y;
float delta;
if( abs( nudgeDelta.x ) < abs( nudgeDelta.y ) )
{
delta = nudgeDelta.y;
}
else
{
delta = nudgeDelta.x;
}
delta = -delta;
if ( !IsSpatialPainting() )
{
CDispMapImageFilter *pFilter = m_FilterRaiseLowerMgr.GetActiveFilter();
if( !pFilter )
return;
// set the dynamic filter data
pFilter->m_DataType = DISPPAINT_CHANNEL_POSITION;
pFilter->m_Scale = ( delta * 0.25 ) * ( float )( ( int )( m_flPaintValueGeo / 10.0f ) + 1 ) ;
// apply the filter to the displacement surface(s)
m_FilterRaiseLowerMgr.Apply( pFilter, pNudgeDisp, m_iPaintAxis, m_vecPaintAxis, m_bAutoSew );
}
else
{
// Get the hit index and check for validity.
int iHit = pNudgeDisp->GetTexelHitIndex();
if ( iHit != -1 )
{
// Initialize the spatial paint data.
SpatialPaintData_t spatialData;
spatialData.m_nEffect = DISPPAINT_EFFECT_RAISELOWER;
spatialData.m_uiBrushType = m_uiBrushType;
spatialData.m_flRadius = m_flSpatialRadius;
spatialData.m_flScalar = delta;
spatialData.m_bNudge = true;
spatialData.m_bNudgeInit = m_bNudgeInit;
pNudgeDisp->GetVert( iHit, spatialData.m_vCenter );
VectorCopy( m_vecPaintAxis, spatialData.m_vPaintAxis );
m_DispPaintMgr.Paint( spatialData, m_bAutoSew );
// Done with the init.
m_bNudgeInit = false;
}
}
// reset the cursor pos
SetCursorPos( m_viewCenter.x, m_viewCenter.y );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ApplyPaintTool( UINT nFlags, const Vector2D &vPoint, CMapDisp *pDisp )
{
switch( m_uiEffect )
{
case DISPPAINT_EFFECT_RAISELOWER:
{
CDispMapImageFilter *pFilter = m_FilterRaiseLowerMgr.GetActiveFilter();
if( pFilter )
{
pFilter->m_DataType = m_iPaintChannel;
if ( m_iPaintChannel == DISPPAINT_CHANNEL_POSITION )
{
pFilter->m_Scale = m_flPaintValueGeo;
}
else if ( m_iPaintChannel == DISPPAINT_CHANNEL_ALPHA )
{
pFilter->m_Scale = m_flPaintValueData;
}
if( m_bRMBDown )
{
pFilter->m_Scale = -pFilter->m_Scale;
}
// apply the filter to the displacement surface(s)
m_FilterRaiseLowerMgr.Apply( pFilter, pDisp, m_iPaintAxis, m_vecPaintAxis, m_bAutoSew );
}
return;
}
case DISPPAINT_EFFECT_MODULATE:
{
// no modulate filters or filter manager currently!
return;
}
case DISPPAINT_EFFECT_SMOOTH:
{
CDispMapImageFilter *pFilter = m_FilterSmoothMgr.GetActiveFilter();
if( pFilter )
{
pFilter->m_DataType = m_iPaintChannel;
pFilter->m_Scale = 1.0f;
int areaValue = 3;
if ( m_iPaintChannel == DISPPAINT_CHANNEL_POSITION )
{
areaValue = ( m_flPaintValueGeo * 2 ) + 1;
}
else if ( m_iPaintChannel == DISPPAINT_CHANNEL_ALPHA )
{
areaValue = ( m_flPaintValueData * 2 ) + 1;
}
if( areaValue < 3 ) { areaValue = 3; }
if( areaValue > 7 ) { areaValue = 7; }
pFilter->m_AreaHeight = areaValue;
pFilter->m_AreaWidth = areaValue;
// apply the filter to the displacement surface(s)
m_FilterSmoothMgr.Apply( pFilter, pDisp, m_iPaintAxis, m_vecPaintAxis, m_bAutoSew );
}
return;
}
case DISPPAINT_EFFECT_RAISETO:
{
CDispMapImageFilter *pFilter = m_FilterRaiseToMgr.GetActiveFilter();
if( pFilter )
{
pFilter->m_DataType = m_iPaintChannel;
if ( m_iPaintChannel == DISPPAINT_CHANNEL_POSITION )
{
pFilter->m_Scale = m_flPaintValueGeo;
}
else if ( m_iPaintChannel == DISPPAINT_CHANNEL_ALPHA )
{
pFilter->m_Scale = m_flPaintValueData;
}
// apply the filter to the displacement surface(s)
m_FilterRaiseToMgr.Apply( pFilter, pDisp, m_iPaintAxis, m_vecPaintAxis, m_bAutoSew );
}
return;
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ApplySpatialPaintTool( UINT nFlags, const Vector2D &vPoint, CMapDisp *pDisp )
{
// Right mouse button only used to paint in a Raise/Lower situation.
if ( ( m_uiEffect != DISPPAINT_EFFECT_RAISELOWER ) && m_bRMBDown )
return;
// Get the hit index and check for validity.
int iHit = pDisp->GetTexelHitIndex();
if ( iHit == -1 )
return;
// Initialize the spatial paint data.
SpatialPaintData_t spatialData;
spatialData.m_nEffect = m_uiEffect;
spatialData.m_uiBrushType = m_uiBrushType;
spatialData.m_flRadius = m_flSpatialRadius;
spatialData.m_flScalar = m_flPaintValueGeo;
spatialData.m_bNudge = false;
if ( m_bRMBDown )
{
spatialData.m_flScalar = -spatialData.m_flScalar;
}
pDisp->GetVert( iHit, spatialData.m_vCenter );
VectorCopy( m_vecPaintAxis, spatialData.m_vPaintAxis );
m_DispPaintMgr.Paint( spatialData, m_bAutoSew );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ApplySculptSpatialPaintTool( CMapView3D *pView, UINT nFlags, const Vector2D &vPoint )
{
// Initialize the spatial paint data.
SpatialPaintData_t spatialData;
spatialData.m_vCenter.Init();
// get hit info
EditDispHandle_t handle = GetHitPos( pView, vPoint );
if( handle != EDITDISPHANDLE_INVALID )
{
m_EditDispHandle = handle;
CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
// Get the hit index and check for validity.
int iHit = pDisp->GetTexelHitIndex();
if ( iHit != -1 )
{
pDisp->GetVert( iHit, spatialData.m_vCenter );
}
}
spatialData.m_nEffect = m_uiEffect;
spatialData.m_uiBrushType = m_uiBrushType;
spatialData.m_flRadius = m_flSpatialRadius;
spatialData.m_flScalar = m_flPaintValueGeo;
spatialData.m_bNudge = false;
if ( m_bRMBDown )
{
spatialData.m_flScalar = -spatialData.m_flScalar;
}
VectorCopy( m_vecPaintAxis, spatialData.m_vPaintAxis );
m_SculptTool->Paint( pView, vPoint, spatialData );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ResizeSpatialRadius_Activate( CMapView3D *pView )
{
// Calculate the center of the view and capture the mouse cursor.
CalcViewCenter( pView );
SetCursorPos( m_viewCenter.x, m_viewCenter.y );
pView->SetCapture();
m_bSpatialRadius = true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ResizeSpatialRadius_Deactivate( void )
{
ReleaseCapture();
m_bSpatialRadius = false;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::ResizeSpatialRadius_Do( void )
{
CPoint cursorPos;
GetCursorPos( &cursorPos );
// Calculate the delta between the cursor from last frame and this one.
CPoint cursorDelta;
cursorDelta.x = cursorPos.x - m_viewCenter.x;
cursorDelta.y = cursorPos.y - m_viewCenter.y;
float flDelta;
if( abs( cursorDelta.x ) < abs( cursorDelta.y ) )
{
flDelta = cursorDelta.y;
}
else
{
flDelta = cursorDelta.x;
}
flDelta = -flDelta;
// Adjust the sphere radius.
m_flSpatialRadius += flDelta;
// reset the cursor pos
SetCursorPos( m_viewCenter.x, m_viewCenter.y );
//
// Update the paint dialog.
//
CFaceEditSheet *pSheet = GetMainWnd()->GetFaceEditSheet();
if( pSheet )
{
pSheet->m_DispPage.UpdatePaintDialogs();
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::HandleSelection( CMapView3D *pView, const Vector2D &vPoint )
{
//
// check for closest solid object
//
ULONG ulFace;
CMapClass *pObject;
bool bShift = ( ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 ) != 0 );
if( ( ( pObject = pView->NearestObjectAt( vPoint, ulFace ) ) != NULL ) )
{
if( pObject->IsMapClass( MAPCLASS_TYPE( CMapSolid ) ) )
{
// get the solid
CMapSolid *pSolid = ( CMapSolid* )pObject;
// setup initial command state
int cmd = scToggle | scClear;
//
// don't "clear" if CTRL is pressed
//
if( GetAsyncKeyState( VK_CONTROL ) & 0x8000 )
{
cmd &= ~scClear;
}
CMapDoc *pDoc = pView->GetMapDoc();
if( !pDoc )
return;
// 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 );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Handle the overriding of displacement triangle tag.
//-----------------------------------------------------------------------------
void CToolDisplace::HandleTagging( CMapView3D *pView, const Vector2D &vPoint )
{
// Get the displacement face (if any) at the 2d point.
ULONG ulFace;
CMapClass *pObject = NULL;
if( ( ( pObject = pView->NearestObjectAt( vPoint, ulFace ) ) != NULL ) )
{
if( pObject->IsMapClass( MAPCLASS_TYPE( CMapSolid ) ) )
{
// Get the face and check for a displacement.
CMapSolid *pSolid = ( CMapSolid* )pObject;
CMapFace *pFace = pSolid->GetFace( ( int )ulFace );
if ( pFace && pFace->HasDisp() )
{
EditDispHandle_t hDisp = pFace->GetDisp();
CMapDisp *pDisp = EditDispMgr()->GetDisp( hDisp );
Vector vecStart, vecEnd;
pView->GetCamera()->BuildRay( vPoint, vecStart, vecEnd );
float flFraction;
int iTri = pDisp->CollideWithDispTri( vecStart, vecEnd, flFraction );
if ( iTri != -1 )
{
if ( m_uiTool == DISPTOOL_TAG_WALKABLE )
{
if ( pDisp->IsTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_BIT ) )
{
pDisp->ToggleTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_VAL );
}
else
{
pDisp->SetTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_BIT );
if ( !pDisp->IsTriTag( iTri, COREDISPTRI_TAG_WALKABLE ) )
{
pDisp->SetTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_VAL );
}
else
{
pDisp->ResetTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_VAL );
}
}
pDisp->UpdateWalkable();
}
else if ( m_uiTool == DISPTOOL_TAG_BUILDABLE )
{
if ( pDisp->IsTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_BIT ) )
{
pDisp->ToggleTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_VAL );
}
else
{
pDisp->SetTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_BIT );
if ( !pDisp->IsTriTag( iTri, COREDISPTRI_TAG_BUILDABLE ) )
{
pDisp->SetTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_VAL );
}
else
{
pDisp->ResetTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_VAL );
}
}
pDisp->UpdateBuildable();
}
else if ( m_uiTool == DISPTOOL_TAG_REMOVE )
{
HandleTaggingRemove( pDisp, iTri );
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CToolDisplace::HandleTaggingRemove( CMapDisp *pDisp, int nTriIndex )
{
pDisp->ToggleTriTag( nTriIndex, COREDISPTRI_TAG_FORCE_REMOVE_BIT );
pDisp->UpdateTriRemove();
}
//-----------------------------------------------------------------------------
// Purpose: Handle the overriding of displacement triangle tag.
//-----------------------------------------------------------------------------
void CToolDisplace::HandleTaggingReset( CMapView3D *pView, const Vector2D &vPoint )
{
// Get the displacement face (if any) at the 2d point.
ULONG ulFace;
CMapClass *pObject = NULL;
if( ( ( pObject = pView->NearestObjectAt( vPoint, ulFace ) ) != NULL ) )
{
if( pObject->IsMapClass( MAPCLASS_TYPE( CMapSolid ) ) )
{
// Get the face and check for a displacement.
CMapSolid *pSolid = ( CMapSolid* )pObject;
CMapFace *pFace = pSolid->GetFace( ( int )ulFace );
if ( pFace && pFace->HasDisp() )
{
EditDispHandle_t hDisp = pFace->GetDisp();
CMapDisp *pDisp = EditDispMgr()->GetDisp( hDisp );
Vector vecStart, vecEnd;
pView->GetCamera()->BuildRay( vPoint, vecStart, vecEnd );
float flFraction;
int iTri = pDisp->CollideWithDispTri( vecStart, vecEnd, flFraction );
if ( iTri != -1 )
{
if ( m_uiTool == DISPTOOL_TAG_WALKABLE )
{
pDisp->ResetTriTag( iTri, COREDISPTRI_TAG_FORCE_WALKABLE_BIT );
pDisp->UpdateWalkable();
}
else if ( m_uiTool == DISPTOOL_TAG_BUILDABLE )
{
pDisp->ResetTriTag( iTri, COREDISPTRI_TAG_FORCE_BUILDABLE_BIT );
pDisp->UpdateBuildable();
}
else if ( m_uiTool == DISPTOOL_TAG_REMOVE )
{
pDisp->ResetTriTag( iTri, COREDISPTRI_TAG_FORCE_REMOVE_BIT );
pDisp->UpdateBuildable();
}
}
}
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
EditDispHandle_t CToolDisplace::GetHitPos( CMapView3D *pView, const Vector2D &vPoint )
{
//
// get ray info
//
Vector rayStart, rayEnd;
pView->GetCamera()->BuildRay( vPoint, rayStart, rayEnd );
// generate selected displacement list
int dispCount = GetSelectedDisps();
if( dispCount == 0 )
return NULL;
// collide against all "active" displacements and set texel hit data
return CollideWithSelectedDisps( rayStart, rayEnd );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CToolDisplace::GetSelectedDisps( void )
{
//
// get a valid displacement manager
//
IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
if( !pDispMgr )
return 0;
// clear the selection list
pDispMgr->SelectClear();
//
// add all selected displacements to "displacement manager"'s selection list
//
CFaceEditSheet *pSheet = GetMainWnd()->GetFaceEditSheet();
if( !pSheet )
return 0;
int faceCount = pSheet->GetFaceListCount();
for( int i = 0; i < faceCount; i++ )
{
CMapFace *pFace = pSheet->GetFaceListDataFace( i );
if( !pFace )
continue;
if( pFace->HasDisp() )
{
EditDispHandle_t handle = pFace->GetDisp();
CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
pDisp->ResetTexelHitIndex();
pDispMgr->AddToSelect( handle );
}
}
// return the number of displacements in list
return pDispMgr->SelectCount();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
EditDispHandle_t CToolDisplace::CollideWithSelectedDisps( const Vector &rayStart, const Vector &rayEnd )
{
EditDispHandle_t handle = EDITDISPHANDLE_INVALID;
float minDist = 99999.9f;
int minIndex = -1;
//
// get a valid displacement manager
//
IWorldEditDispMgr *pDispMgr = GetActiveWorldEditDispManager();
if( !pDispMgr )
return NULL;
int dispCount = pDispMgr->SelectCount();
for( int i = 0; i < dispCount; i++ )
{
// get the current displacement
CMapDisp *pDisp = pDispMgr->GetFromSelect( i );
if( !pDisp )
continue;
bool bCollide = RayAABBTest( pDisp, rayStart, rayEnd );
if( bCollide )
{
Vector point;
int size = pDisp->GetSize();
for( int j = 0; j < size; j++ )
{
// get current point
pDisp->GetVert( j, point );
// find point closest to ray
float dist = DistFromPointToRay( rayStart, rayEnd, point );
if( dist < minDist )
{
CMapFace *pFace = ( CMapFace* )pDisp->GetParent();
handle = pFace->GetDisp();
minDist = dist;
minIndex = j;
}
}
}
}
//
// set the texel hit index
//
if( handle != EDITDISPHANDLE_INVALID )
{
CMapDisp *pDisp = EditDispMgr()->GetDisp( handle );
pDisp->SetTexelHitIndex( minIndex );
}
return handle;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::RayAABBTest( CMapDisp *pDisp, const Vector &rayStart, const Vector &rayEnd )
{
//
// make planes
//
PLANE planes[6];
Vector boxMin, boxMax;
pDisp->GetBoundingBox( boxMin, boxMax );
BuildParallelepiped( boxMin, boxMax, planes );
bool bCollide = false;
for( int planeIndex = 0; planeIndex < 6; planeIndex++ )
{
bCollide = RayPlaneTest( &planes[planeIndex], rayStart, rayEnd );
if( !bCollide )
return false;
}
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::BuildParallelepiped( const Vector &boxMin, const Vector &boxMax,
PLANE planes[6] )
{
int planeIndex = 0;
for( int axis = 0; axis < 3; axis++ )
{
for( int direction = -1; direction < 2; direction += 2 )
{
// clear the current plane info
VectorClear( planes[planeIndex].normal );
planes[planeIndex].normal[axis] = direction;
if( direction == 1 )
{
planes[planeIndex].dist = boxMax[axis];
}
else
{
planes[planeIndex].dist = -boxMin[axis];
}
planeIndex++;
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::RayPlaneTest( PLANE *pPlane, const Vector& rayStart, const Vector& rayEnd /*, float *fraction*/ )
{
//
// get the distances both trace start and end from the bloated plane
//
float distStart = DotProduct( rayStart, pPlane->normal ) - pPlane->dist;
float distEnd = DotProduct( rayEnd, pPlane->normal ) - pPlane->dist;
//
// no collision - both points are in front or behind of the given plane
//
if( ( distStart > 0.0f ) && ( distEnd > 0.0f ) )
return false;
if( ( distStart > 0.0f ) && ( distEnd > 0.0f ) )
return false;
// calculate the parameterized "t" component along the ray
//*fraction = distStart / ( distStart - distEnd );
// collision
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float CToolDisplace::DistFromPointToRay( const Vector& rayStart, const Vector& rayEnd,
const Vector& point )
{
//
// calculate the ray
//
Vector ray;
VectorSubtract( rayEnd, rayStart, ray );
VectorNormalize( ray );
//
// get a ray to point
//
Vector seg;
VectorSubtract( point, rayStart, seg );
//
// project point segment onto ray - get perpendicular point
//
float value = DotProduct( ray, seg );
VectorScale( ray, value, ray );
VectorAdd( rayStart, ray, ray );
//
// find the distance between the perpendicular point and point
//
VectorSubtract( ray, point, seg );
float dist = VectorLength( seg );
return dist;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CToolDisplace::AddFiltersToManagers( void )
{
int count = m_FilterLoaderMgr.GetFilterCount();
for( int ndxFilter = 0; ndxFilter < count; ndxFilter++ )
{
CDispMapImageFilter *pFilter = m_FilterLoaderMgr.GetFilter( ndxFilter );
if( pFilter )
{
switch( pFilter->m_Type )
{
case DISPPAINT_EFFECT_RAISELOWER:
{
m_FilterRaiseLowerMgr.Add( pFilter );
break;
}
case DISPPAINT_EFFECT_RAISETO:
{
m_FilterRaiseToMgr.Add( pFilter );
break;
}
case DISPPAINT_EFFECT_SMOOTH:
{
m_FilterSmoothMgr.Add( pFilter );
break;
}
}
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CToolDisplace::LoadFilters( const char *filename )
{
//
// Open the file.
//
CChunkFile File;
ChunkFileResult_t eResult = File.Open( filename, ChunkFile_Read );
if( eResult != ChunkFile_Ok )
{
Msg( mwError, "Couldn't load filter file %s!\n", filename );
}
//
// Read the file.
//
if (eResult == ChunkFile_Ok)
{
//
// Set up handlers for the subchunks that we are interested in.
//
CChunkHandlerMap Handlers;
Handlers.AddHandler( "Filter", ( ChunkHandler_t )CToolDisplace::LoadFiltersCallback, this );
File.PushHandlers( &Handlers );
//
// Read the sub-chunks. We ignore keys in the root of the file, so we don't pass a
// key value callback to ReadChunk.
//
while (eResult == ChunkFile_Ok)
{
eResult = File.ReadChunk();
}
if (eResult == ChunkFile_EOF)
{
eResult = ChunkFile_Ok;
}
File.PopHandlers();
}
return( eResult == ChunkFile_Ok );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
ChunkFileResult_t CToolDisplace::LoadFiltersCallback( CChunkFile *pFile, CToolDisplace *pDisplaceTool )
{
//
// allocate a new filter
//
CDispMapImageFilter *pFilter = pDisplaceTool->m_FilterLoaderMgr.Create();
if( !pFilter )
return ChunkFile_Fail;
// load the filter data
ChunkFileResult_t eResult = pFilter->LoadFilter( pFile );
return( eResult );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pRender -
// *pTool -
//-----------------------------------------------------------------------------
void CToolDisplace::RenderPaintSphere( CRender3D *pRender )
{
CMapDisp *pDisp = GetEditDisp();
if (pDisp == NULL)
return;
// Get the sphere center.
int iHit = pDisp->GetTexelHitIndex();
if ( iHit == -1 )
return;
// Get the sphere center and radius.
Vector vCenter;
pDisp->GetVert( iHit, vCenter );
float flRadius = GetSpatialRadius();
int size = ( int )( flRadius * 0.05f );
if ( size < 6 ) { size = 6; }
if ( size > 12 ) { size = 12; }
// Render the sphere.
if ( !IsNudging() )
{
pRender->RenderWireframeSphere( vCenter, flRadius, size, size, 0, 255, 0 );
}
else
{
pRender->RenderWireframeSphere( vCenter, flRadius, size, size, 255, 255, 0 );
}
// Render the displacement axis (as an arrow).
int nPaintAxis;
Vector vPaintAxis;
GetPaintAxis( nPaintAxis, vPaintAxis );
if( nPaintAxis == DISPPAINT_AXIS_SUBDIV )
{
pDisp->GetSubdivNormal( iHit, vPaintAxis );
}
float flBloat = flRadius * 0.15f;
pRender->RenderArrow( vCenter, vCenter + ( vPaintAxis * ( flRadius + flBloat ) ), 255, 255, 0 );
// Render cube at center point.
Vector vBoxMin, vBoxMax;
for ( int iAxis = 0; iAxis < 3; iAxis++ )
{
vBoxMin[iAxis] = vCenter[iAxis] - ( flBloat * 0.25f );
vBoxMax[iAxis] = vCenter[iAxis] + ( flBloat * 0.25f );
}
pRender->RenderBox( vBoxMin, vBoxMax, 255, 255, 0, SELECT_NONE );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pRender -
// bNudge -
//-----------------------------------------------------------------------------
void CToolDisplace::RenderHitBox( CRender3D *pRender )
{
CMapDisp *pDisp = GetEditDisp();
if (pDisp == NULL)
return;
//
// get selection
//
int index = pDisp->GetTexelHitIndex();
if( index == -1 )
return;
//
// get the displacement map width and height
//
int width = pDisp->GetWidth();
int height = pDisp->GetHeight();
Vector seg[2];
Vector points[2];
pDisp->GetVert( 0, points[0] );
pDisp->GetVert( ( width - 1 ), points[1] );
VectorSubtract( points[1], points[0], seg[0] );
pDisp->GetVert( ( ( width - 1 ) * height ), points[1] );
VectorSubtract( points[1], points[0], seg[1] );
VectorAdd( seg[0], seg[1], seg[0] );
VectorScale( seg[0], 0.5f, seg[0] );
//
// determine a good size to make the "box" surrounding the selected point
//
float length = VectorLength( seg[0] );
length *= 0.025f;
//
// render the box
//
pDisp->GetVert( index, points[0] );
Vector minb, maxb;
minb[0] = points[0][0] - length;
minb[1] = points[0][1] - length;
minb[2] = points[0][2] - length;
maxb[0] = points[0][0] + length;
maxb[1] = points[0][1] + length;
maxb[2] = points[0][2] + length;
if( !IsNudging() )
{
pRender->RenderWireframeBox( minb, maxb, 0, 255, 0 );
}
else
{
pRender->RenderWireframeBox( minb, maxb, 255, 255, 0 );
}
//
// render the normal
//
// get hit box origin
Vector hbOrigin;
pDisp->GetVert( index, hbOrigin );
// get 4x length
float length4 = length * 4.0f;
int paintAxis;
Vector vecPaint;
GetPaintAxis( paintAxis, vecPaint );
if( paintAxis == DISPPAINT_AXIS_SUBDIV )
{
pDisp->GetSubdivNormal( index, vecPaint );
}
//
// render the normal -- just a yellow line at this point
//
pRender->RenderArrow( hbOrigin, hbOrigin + ( vecPaint * length4 ), 255, 255, 0 );
#if 0
CMeshBuilder meshBuilder;
IMesh *pMesh = MaterialSystemInterface()->GetDynamicMesh();
meshBuilder.Begin( pMesh, MATERIAL_LINES, 1 );
meshBuilder.Position3f( hbOrigin.x, hbOrigin.y, hbOrigin.z );
meshBuilder.Color3ub( 255, 255, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( hbOrigin.x + ( normal.x * length4 ),
hbOrigin.y + ( normal.y * length4 ),
hbOrigin.z + ( normal.z * length4 ) );
meshBuilder.Color3ub( 255, 255, 0 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pRender -
//-----------------------------------------------------------------------------
void CToolDisplace::RenderTool3D(CRender3D *pRender)
{
unsigned int uiTool = GetTool();
if ( uiTool == DISPTOOL_PAINT )
{
if ( IsSpatialPainting() )
{
RenderPaintSphere( pRender );
}
else
{
RenderHitBox( pRender );
}
}
if ( uiTool == DISPTOOL_PAINT_SCULPT )
{
m_SculptTool->RenderTool3D( pRender );
}
}