H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 22:27:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
30a97f855e
source-engine/hammer/box3d.cpp

1176 lines
27 KiB
C++
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "stdafx.h"
#include "Box3D.h"
#include "GlobalFunctions.h"
#include "MainFrm.h" // dvs: hack for tools migration code
#include "MapDoc.h"
#include "MapView2D.h"
#include "Options.h"
#include "Render2D.h"
#include "Render3D.h"
#include "RenderUtils.h"
#include "resource.h"
#include "StatusBarIDs.h"
#include "hammer_mathlib.h"
#include "vgui/Cursor.h"
#include "HammerVGui.h"
#include <VGuiMatSurface/IMatSystemSurface.h>
#include "camera.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
#pragma warning(disable:4244)
extern float g_MAX_MAP_COORD; // dvs: move these into Globals.h!!
extern float g_MIN_MAP_COORD; // dvs: move these into Globals.h!!
WorldUnits_t Box3D::m_eWorldUnits = Units_None;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Box3D::Box3D(void)
{
SetEmpty();
SetDrawFlags(0);
m_TranslateMode = modeScale;
m_vTranslationFixPoint.Init();
m_TranslateHandle.Init();
m_bEnableHandles = true;
SetDrawColors(Options.colors.clrToolHandle, Options.colors.clrToolBlock);
}
void Box3D::SetEmpty()
{
Tool3D::SetEmpty();
ResetBounds();
if ( m_pDocument )
{
m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pView -
// pt - Point in client coordinates.
// bValidOnly -
// Output :
//-----------------------------------------------------------------------------
int Box3D::HitTest(CMapView *pView, const Vector2D &ptClient, bool bTestHandles)
{
bool bHit = false;
if ( pView->HitTest( ptClient, bmins, bmaxs ) )
{
// The point is inside the main rect.
m_LastHitTestHandle.Init();
bHit = true;
}
if ( !m_bEnableHandles || !bTestHandles )
{
// Handles are turned off, so we don't need to do any more testing.
// Return whether we hit the main rect or not.
return bHit;
}
// check if we hit a handle
Vector handles[3*3*3];
int numHandles = GetVisibleHandles( handles, pView, m_TranslateMode );
Vector vOffset(HANDLE_OFFSET,HANDLE_OFFSET,HANDLE_OFFSET);
if ( pView->IsOrthographic() )
{
vOffset /= pView->GetCamera()->GetZoom();
}
else
{
vOffset.Init();
}
Vector vCenter = (bmins+bmaxs)/2;
Vector vDelta = (bmaxs + vOffset) - vCenter;
for ( int i = 0; i<numHandles; i++ )
{
Vector pos = vCenter + vDelta * handles[i];
if ( HitRect( pView, ptClient, pos, HANDLE_RADIUS ) )
{
// remember handle found
m_LastHitTestHandle = handles[i];
bHit = true;
break;
}
}
return bHit;
}
//-----------------------------------------------------------------------------
// Purpose: Set the cursor based on the hit test results and current translate mode.
// Input : eHandleHit - The handle that the cursor is over.
// eTransformMode - The current transform mode of the tool - scale, rotate, or shear.
//-----------------------------------------------------------------------------
unsigned long Box3D::UpdateCursor(CMapView *pView, const Vector &vHandleHit, TransformMode_t eTransformMode)
{
if ( eTransformMode == modeMove || vHandleHit.IsZero() )
return vgui::dc_sizeall;
if ( eTransformMode == modeNone )
return vgui::dc_arrow;
if (eTransformMode == modeRotate)
return g_pMatSystemSurface->CreateCursorFromFile("Resource/rotate.cur");
// cursor icon depends on handle and map view :
Vector2D ptOrigin; pView->WorldToClient( ptOrigin, Vector(0,0,0) );
Vector2D ptHit; pView->WorldToClient( ptHit, vHandleHit );
Vector2D pt; pt.x = ptHit.x - ptOrigin.x; pt.y = ptHit.y - ptOrigin.y;
if (eTransformMode == modeScale)
{
if ( pt.x > 0 )
{
if ( pt.y > 0 )
return vgui::dc_sizenwse;
else if ( pt.y < 0 )
return vgui::dc_sizenesw;
else
return vgui::dc_sizewe;
}
else if ( pt.x < 0 )
{
if ( pt.y > 0 )
return vgui::dc_sizenesw;
else if ( pt.y < 0 )
return vgui::dc_sizenwse;
else
return vgui::dc_sizewe;
}
else // pt.x == 0
{
if ( pt.y != 0 )
return vgui::dc_sizens;
else
return vgui::dc_sizeall;
}
}
else if (eTransformMode == modeShear)
{
if ( pt.x == 0 )
return vgui::dc_sizewe;
else
return vgui::dc_sizens;
}
return vgui::dc_none;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bEnable -
//-----------------------------------------------------------------------------
void Box3D::EnableHandles(bool bEnable)
{
m_bEnableHandles = bEnable;
}
//-----------------------------------------------------------------------------
// Purpose: Finds the corner nearest to a given point in world coordinates.
// Output : Returns the corner in world coordinates (axThird is always 0).
//-----------------------------------------------------------------------------
const Vector Box3D::NearestCorner( const Vector2D &vPoint, CMapView *pView, const Vector *pCustomHandleBox )
{
Vector vHandles[3*3*3];
float fBestDist = 999999.9f;
Vector vBestCorner(0,0,0);
int nFace = -1;
Vector start,end,pos;
pView->BuildRay( vPoint, start,end );
float dist = IntersectionLineAABBox( bmins, bmaxs, start, end, nFace );
if ( dist < 0 )
return vBestCorner;
// get point where we hit the bbox
pos = end-start; VectorNormalize( pos );
pos = start + pos*dist;
// mode rotate has only corner handles
int nNumHandles = GetVisibleHandles( vHandles, pView, modeRotate );
for ( int i=0; i<nNumHandles; i++ )
{
Vector vecCorner;
HandleToWorld( vecCorner, vHandles[i], pCustomHandleBox );
float distance = VectorLength( vecCorner - pos );
if ( distance < fBestDist )
{
fBestDist = distance;
vBestCorner = vecCorner;
}
}
return vBestCorner;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pt -
// ptForceMoveRef -
// Output : Returns TRUE if pt hits a handle or is in box area, FALSE otherwise.
//-----------------------------------------------------------------------------
void Box3D::StartTranslation(
CMapView *pView,
const Vector2D &vPoint,
const Vector &vHandleOrigin,
const Vector *pRefPoint,
const Vector *pCustomHandleBox )
{
if ( vHandleOrigin.IsZero() )
{
// we hit the main body, switch to move translation then
m_LastTranslateMode = m_TranslateMode;
m_TranslateMode = modeMove;
}
m_TranslateHandle = vHandleOrigin;
m_bPreventOverlap = true;
if ( pRefPoint )
{
// transformation reference point was given
m_vTranslationFixPoint = *pRefPoint;
}
else
{
// build reference point based on mode & handle
if (m_TranslateMode == modeRotate)
{
// user center of object for rotation
m_vTranslationFixPoint = (bmins + bmaxs) / 2;
}
else if (m_TranslateMode == modeMove)
{
// chose nearest corner to
m_vTranslationFixPoint = NearestCorner( vPoint, pView, pCustomHandleBox );
}
else
{
// find opposite point to handle
m_vTranslationFixPoint.Init();
for ( int i=0; i<3; i++ )
{
float handle = m_TranslateHandle[i];
if ( handle > 0 )
{
m_vTranslationFixPoint[i] = bmins[i];
}
else if ( handle < 0 )
{
m_vTranslationFixPoint[i] = bmaxs[i];
}
}
}
}
// get axis normals from picked face
Vector v1,v2,v3,vOrigin;
// if no valid translation handle, cull against BBox
if ( m_TranslateMode == modeMove )
{
int nFace;
pView->BuildRay( vPoint, v1, v2 );
IntersectionLineAABBox( bmins, bmaxs, v1, v2, nFace );
if ( nFace >= 0 )
{
// get axis & normals of face we hit
GetAxisFromFace( nFace, v1, v2, v3 );
}
else
{
pView->GetBestTransformPlane( v1,v2,v3 );
}
vOrigin = m_vTranslationFixPoint;
}
else
{
pView->GetBestTransformPlane( v1,v2,v3 );
HandleToWorld( vOrigin, m_TranslateHandle );
}
// set temp transformation plane
SetTransformationPlane(vOrigin, v1, v2, v3 );
// align translation plane to world origin
ProjectOnTranslationPlane( vec3_origin, vOrigin, 0 );
// set transformation plane
SetTransformationPlane(vOrigin, v1, v2, v3 );
Tool3D::StartTranslation( pView, vPoint, false );
m_TransformMatrix.Identity();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pszBuf -
//-----------------------------------------------------------------------------
void Box3D::GetStatusString(char *pszBuf)
{
*pszBuf = '\0';
Vector mins(0,0,0);
Vector maxs(0,0,0);
if ( IsValidBox() )
{
mins = bmins;
maxs = bmaxs;
}
if ( IsTranslating() )
{
TranslateBox( mins, maxs );
}
Vector size = maxs - mins;
Vector center = ( maxs + mins ) * 0.5f;
if ( !IsTranslating() || m_TranslateMode == modeScale || m_TranslateMode == modeMove )
{
if (!IsEmpty())
{
if ( IsTranslating() && m_TranslateMode == modeMove )
{
center = m_vTranslationFixPoint;
TranslatePoint( center );
}
switch (m_eWorldUnits)
{
case Units_None:
{
sprintf(pszBuf, " %dw %dl %dh @(%.0f %.0f %.0f)",
(int)fabs(size.x), (int)fabs(size.y), (int)fabs(size.z),
center.x,center.y,center.z );
break;
}
case Units_Inches:
{
sprintf(pszBuf, " %d\"w %d\"l %d\"h", (int)fabs(size.x), (int)fabs(size.y), (int)fabs(size.z));
break;
}
case Units_Feet_Inches:
{
int nFeetWide = (int)fabs(size.x) / 12;
int nInchesWide = (int)fabs(size.x) % 12;
int nFeetLong = (int)fabs(size.y) / 12;
int nInchesLong = (int)fabs(size.y) % 12;
int nFeetHigh = (int)fabs(size.z) / 12;
int nInchesHigh = (int)fabs(size.z) % 12;
sprintf(pszBuf, " %d' %d\"w %d' %d\"l %d' %d\"h", nFeetWide, nInchesWide, nFeetLong, nInchesLong, nFeetHigh, nInchesHigh);
break;
}
}
}
}
else if ( m_TranslateMode == modeShear )
{
sprintf(pszBuf, " shear: %d %d %d ", (int)m_vTranslation.x, (int)m_vTranslation.y, (int)m_vTranslation.z );
}
else if ( m_TranslateMode == modeRotate )
{
int rotAxis = GetTransformationAxis();
if ( rotAxis != -1 )
{
sprintf(pszBuf, " %.2f%c", m_vTranslation[abs(rotAxis+2)%3], 0xF8);
}
else
{
sprintf(pszBuf, " %.2f %.2f %.2f%c", m_vTranslation.x, m_vTranslation.y, m_vTranslation.z, 0xF8);
}
}
else
{
Assert( 0 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Box3D::UpdateStatusBar()
{
char szBuf[MAX_PATH];
GetStatusString(szBuf);
SetStatusText(SBI_SIZE, szBuf);
}
int Box3D::GetVisibleHandles( Vector *handles, CMapView *pView, int nMode )
{
bool bCorners, bEdges, bFaces;
bool bIs2D = pView->IsOrthographic();
Vector vViewAxis = pView->GetViewAxis();
Vector vViewPoint; pView->GetCamera()->GetViewPoint( vViewPoint );
if ( bIs2D )
{
bCorners = false;
bEdges = nMode == modeRotate || nMode == modeScale;
bFaces = nMode == modeShear || nMode == modeScale;
}
else
{
bCorners = nMode == modeRotate || nMode == modeScale;
bEdges = nMode == modeScale;
bFaces = nMode == modeShear;
}
if ( !bCorners && !bEdges && !bFaces )
return 0;
int count = 0;
for ( int x = -1; x < 2; x++ )
{
if ( bIs2D && (x != 0) && (fabs(vViewAxis.x) == 1) )
continue;
for ( int y = -1; y < 2; y++ )
{
if ( bIs2D && (y != 0) && (fabs(vViewAxis.y) == 1) )
continue;
for ( int z = -1; z<2; z++)
{
if ( bIs2D && (z != 0) && (fabs(vViewAxis.z) == 1) )
continue;
int n = abs(x) + abs(y) + abs(z);
if ( n == 0 )
{
// don't add center as handle
continue;
}
else if ( n == 1 )
{
if ( !bFaces )
continue;
}
else if ( n == 2 )
{
if ( !bEdges )
continue;
}
else
{
if ( !bCorners )
continue;
}
if ( !bIs2D )
{
Vector vHandle; HandleToWorld( vHandle, Vector(x,y,z) );
Vector vDelta = vHandle - vViewPoint;
float fDistance = VectorLength( vDelta );
int nFace;
vDelta /= fDistance; // normalize
if ( DotProduct(vDelta,vViewAxis) < 0 )
continue;
float fIntersection = IntersectionLineAABBox( bmins, bmaxs, vViewPoint, vViewPoint+vDelta*99999, nFace );
if ( fIntersection >= 0 && fIntersection*1.01 < fDistance )
continue;
}
// add handle as visible
handles[count] = Vector(x,y,z);
count++;
}
}
}
return count;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : ptWorld - point to update with in world coordinates
// uConstraints -
// dragSize -
// Output :
//-----------------------------------------------------------------------------
bool Box3D::UpdateTranslation(const Vector &vUpdate, UINT uConstraints)
{
if (m_TranslateMode == modeNone)
{
return false;
}
else if ( m_TranslateMode == modeRotate )
{
Vector vCenter; ProjectOnTranslationPlane( m_vTranslationFixPoint, vCenter );
Vector vStart; HandleToWorld( vStart, m_TranslateHandle );
Vector v1 = vStart-vCenter; VectorNormalize( v1 );
Vector v2 = (vStart+vUpdate)-vCenter; VectorNormalize( v2 );
float volume = DotProduct( m_vPlaneNormal, CrossProduct( v1, v2) );
float angle = RAD2DEG( acos( DotProduct( v1,v2) ) );
if (uConstraints & constrainSnap)
{
angle += 7.5;
angle -= fmod(double(angle), double(15.0));
}
else
{
angle += 0.25;
angle -= fmod(double(angle), double(.5));
}
if ( volume < 0 )
angle = -angle;
if ( fabs(m_vPlaneNormal.x) == 1 )
m_vTranslation.z = (m_vPlaneNormal.x>0)?angle:-angle;
else if ( fabs(m_vPlaneNormal.y) == 1 )
m_vTranslation.x = (m_vPlaneNormal.y>0)?angle:-angle;
else if ( fabs(m_vPlaneNormal.z) == 1 )
m_vTranslation.y = (m_vPlaneNormal.z>0)?angle:-angle;
}
else
{
if ( vUpdate == m_vTranslation )
return false; // no change
m_vTranslation = vUpdate;
// restrict translation, snap to grid, prevent overlap etc
// make sure reference point snaps if enabled
if ( uConstraints )
{
// project back on projection plane
Vector pos;
if ( m_TranslateMode == modeMove )
{
// when moving opbject make sure reference point is on grid
pos = m_vTranslationFixPoint;
}
else
{
// otherwise translated handle should be on grid
HandleToWorld( pos, m_TranslateHandle);
}
ProjectOnTranslationPlane( pos + m_vTranslation, m_vTranslation, uConstraints );
m_vTranslation -= pos;
}
if ( m_TranslateMode == modeScale )
{
for ( int i=0; i<3; i++ )
{
float handle = m_TranslateHandle[i];
if ( handle > 0 )
{
float newMaxs = bmaxs[i] + m_vTranslation[i];
if( m_bPreventOverlap && newMaxs <= bmins[i] )
{
m_vTranslation[i] = bmins[i] - bmaxs[i] + 1;
}
}
else if ( handle < 0 )
{
float newMins = bmins[i] + m_vTranslation[i];
if( m_bPreventOverlap && newMins >= bmaxs[i] )
{
m_vTranslation[i] = bmaxs[i] - bmins[i] - 1;
}
}
}
}
}
UpdateTransformMatrix();
m_pDocument->UpdateAllViews( MAPVIEW_UPDATE_TOOL );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : dwHandleColor -
// dwBoxColor -
//-----------------------------------------------------------------------------
void Box3D::SetDrawColors(COLORREF dwHandleColor, COLORREF dwBoxColor)
{
if (dwHandleColor != 0xffffffff)
{
m_clrHandle = dwHandleColor;
}
if (dwBoxColor != 0xffffffff)
{
m_clrBox = dwBoxColor;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pt -
//-----------------------------------------------------------------------------
void Box3D::TranslatePoint(Vector& pt)
{
TransformPoint( m_TransformMatrix, pt );
}
const VMatrix& Box3D::GetTransformMatrix()
{
return m_TransformMatrix;
}
void Box3D::UpdateTransformMatrix()
{
m_TransformMatrix.Identity();
if ( m_TranslateMode == modeNone )
{
return;
}
else if ( m_TranslateMode == modeMove )
{
m_TransformMatrix.SetTranslation( m_vTranslation );
return;
}
else if ( m_TranslateMode == modeScale )
{
Vector vScale( 1,1,1);
Vector vMove(0,0,0);
Vector vSize = bmaxs-bmins;
for ( int i=0; i<3; i++ )
{
float handle = m_TranslateHandle[i];
if ( vSize[i] == 0 )
continue;
if ( handle > 0 )
{
vScale[i] = (m_vTranslation[i]+vSize[i]) / vSize[i];
vMove[i] = m_vTranslation[i] / 2;
}
else if ( handle < 0 )
{
vScale[i] = (-m_vTranslation[i]+vSize[i]) / vSize[i];
vMove[i] = m_vTranslation[i] / 2;
}
}
m_TransformMatrix = m_TransformMatrix.Scale( vScale );
m_TransformMatrix.SetTranslation( vMove );
}
else if ( m_TranslateMode == modeShear )
{
Vector vSize = bmaxs-bmins;
int axisS = -1; // shear axis that wont change
int axisA = -1; // first shear axis
int axisB = -1; // second shear axis
for ( int i=0; i<3; i++ )
{
float handle = m_TranslateHandle[i];
if ( handle > 0 )
{
Assert( axisS == -1);
axisS = i;
}
else if ( handle < 0 )
{
Assert( axisS == -1);
axisS = i;
vSize *= -1;
}
else
{
if ( axisA == -1 )
axisA = i;
else
axisB = i;
}
}
Assert( (axisA!=-1) && (axisB!=-1) && (axisS!=-1) );
m_TransformMatrix.m[axisA][axisS] = (m_vTranslation[axisA])/(vSize[axisS]);
m_TransformMatrix.m[axisB][axisS] = (m_vTranslation[axisB])/(vSize[axisS]);
}
else if ( m_TranslateMode == modeRotate )
{
QAngle angle = *(QAngle*)&m_vTranslation; // buuuhhh
m_TransformMatrix.SetupMatrixOrgAngles( vec3_origin, angle );
}
// apply m_vTranslationFixPoint offset
Vector offset;
m_TransformMatrix.V3Mul( m_vTranslationFixPoint, offset );
offset = m_vTranslationFixPoint - offset;
m_TransformMatrix.m[0][3] += offset[0];
m_TransformMatrix.m[1][3] += offset[1];
m_TransformMatrix.m[2][3] += offset[2];
}
void Box3D::TranslateBox(Vector& mins, Vector& maxs)
{
if ( m_TranslateMode == modeNone )
{
return;
}
if ( m_TranslateMode == modeMove )
{
mins += m_vTranslation;
maxs += m_vTranslation;
}
else if ( m_TranslateMode == modeScale )
{
for ( int i=0; i<3; i++ )
{
float handle = m_TranslateHandle[i];
if ( handle > 0 )
{
maxs[i] += m_vTranslation[i];
}
else if ( handle < 0 )
{
mins[i] += m_vTranslation[i];
}
}
}
else if ( m_TranslateMode == modeShear )
{
TranslatePoint( mins );
TranslatePoint( maxs );
}
else if ( m_TranslateMode == modeRotate )
{
TranslatePoint( mins );
TranslatePoint( maxs );
}
NormalizeBox( mins, maxs );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bSave -
//-----------------------------------------------------------------------------
void Box3D::FinishTranslation(bool bSave)
{
if( bSave )
{
Vector newMins = bmins;
Vector newMaxs = bmaxs;
TranslateBox( newMins, newMaxs );
LimitBox( newMins, newMaxs, g_MAX_MAP_COORD );
SetBounds( newMins, newMaxs );
m_bEmpty = false;
}
// if we are finished with moving the selection, switch back to the
// original translation mode
if ( m_TranslateMode == modeMove )
{
m_TranslateMode = m_LastTranslateMode;
}
Tool3D::FinishTranslation(bSave);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Box3D::ToggleTranslateMode(void)
{
if( m_TranslateMode == modeMove )
{
m_TranslateMode = modeScale;
}
else if( m_TranslateMode == modeScale )
{
m_TranslateMode = modeRotate;
}
else if( m_TranslateMode == modeRotate )
{
m_TranslateMode = modeShear;
}
else if( m_TranslateMode == modeShear )
{
m_TranslateMode = modeScale; // don't go back to move mode
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : dwFlags -
//-----------------------------------------------------------------------------
void Box3D::SetDrawFlags(DWORD dwFlags)
{
m_dwDrawFlags = dwFlags;
}
void Box3D::RenderHandles2D(CRender2D *pRender, const Vector &mins, const Vector &maxs)
{
Vector handles[3*3*3];
int numHandles = GetVisibleHandles( handles, pRender->GetView(), m_TranslateMode );
if ( numHandles == 0 )
return;
pRender->SetHandleColor( GetRValue(m_clrHandle), GetGValue(m_clrHandle), GetBValue(m_clrHandle) );
if ( m_TranslateMode == modeRotate )
{
pRender->SetHandleStyle( HANDLE_RADIUS, CRender::HANDLE_CIRCLE );
}
else
{
pRender->SetHandleStyle( HANDLE_RADIUS, CRender::HANDLE_SQUARE );
}
Vector vCenter = (mins+maxs)/2;
Vector vDelta = maxs - vCenter;
Vector2D vOffset;
bool bPopMode = pRender->BeginClientSpace();
for ( int i=0; i<numHandles; i++)
{
pRender->TransformNormal( vOffset, handles[i] );
vOffset.x = fsign(vOffset.x);
vOffset.y = fsign(vOffset.y);
vOffset*=HANDLE_OFFSET;
Vector pos = vCenter + vDelta * handles[i];
pRender->DrawHandle( pos, &vOffset );
}
if ( bPopMode )
pRender->EndClientSpace();
}
void Box3D::RenderHandles3D(CRender3D *pRender, const Vector &mins, const Vector &maxs)
{
Vector handles[3*3*3];
int numHandles = GetVisibleHandles( handles, pRender->GetView(), m_TranslateMode );
if ( numHandles == 0 )
return;
Vector vCenter = (mins+maxs)/2;
Vector vDelta = maxs - vCenter;
if ( m_TranslateMode == modeRotate )
{
pRender->SetHandleStyle( HANDLE_RADIUS, CRender::HANDLE_CIRCLE );
}
else
{
pRender->SetHandleStyle( HANDLE_RADIUS, CRender::HANDLE_SQUARE );
}
pRender->SetHandleColor( GetRValue(m_clrHandle), GetGValue(m_clrHandle), GetBValue(m_clrHandle) );
pRender->PushRenderMode( RENDER_MODE_FLAT_NOZ );
bool bPopMode = pRender->BeginClientSpace();
for ( int i=0; i<numHandles; i++)
{
Vector pos = vCenter + vDelta * handles[i];
pRender->DrawHandle( pos );
}
if ( bPopMode )
pRender->EndClientSpace();
pRender->PopRenderMode();
}
void Box3D::HandleToWorld( Vector &vWorld, const Vector &vHandle, const Vector *pCustomHandleBox)
{
Vector vCenter, vDelta;
if ( pCustomHandleBox )
{
vCenter = (pCustomHandleBox[0] + pCustomHandleBox[1]) / 2;
vDelta = pCustomHandleBox[1] - vCenter;
}
else
{
vCenter = (bmins+bmaxs)/2;
vDelta = bmaxs - vCenter;
}
vWorld = vCenter + (vDelta * vHandle);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pDC -
// bounds -
//-----------------------------------------------------------------------------
void Box3D::RenderTool2D(CRender2D *pRender)
{
Vector mins = bmins;
Vector maxs = bmaxs;
CMapView2D *pView = (CMapView2D*)pRender->GetView();
Assert( pRender );
if ( IsTranslating() )
{
TranslateBox( mins, maxs );
}
else if ( IsEmpty() )
{
return;
}
if ( m_dwDrawFlags & boundstext)
{
DrawBoundsText(pRender, mins, maxs, DBT_TOP | DBT_LEFT);
}
if ( IsTranslating() )
{
pRender->PushRenderMode( RENDER_MODE_DOTTED );
pRender->SetDrawColor( GetRValue(Options.colors.clrToolDrag), GetGValue(Options.colors.clrToolDrag), GetBValue(Options.colors.clrToolDrag) );
}
else if (!(m_dwDrawFlags & thicklines))
{
pRender->PushRenderMode( RENDER_MODE_DOTTED );
pRender->SetDrawColor( GetRValue(m_clrBox), GetGValue(m_clrBox), GetBValue(m_clrBox) );
}
else
{
pRender->PushRenderMode( RENDER_MODE_FLAT_NOZ );
pRender->SetDrawColor( GetRValue(m_clrBox), GetGValue(m_clrBox), GetBValue(m_clrBox) );
}
// render bounds
if ( !IsTranslating() || m_TranslateMode == modeScale || m_TranslateMode == modeMove )
{
// draw simple rectangle
pRender->DrawRectangle( mins, maxs, false, 0 );
}
else
{
// during rotation or shearing, draw transformed bounding box
Vector v[4];
// init all points to center
v[0] = v[1] = v[2] = v[3] = (bmins+bmaxs) / 2;
int axis = pView->axHorz;
v[0][axis] = v[1][axis] = bmins[axis];
v[2][axis] = v[3][axis] = bmaxs[axis];
axis = pView->axVert;
v[1][axis] = v[2][axis] = bmins[axis];
v[0][axis] = v[3][axis] = bmaxs[axis];
for ( int i=0; i<4; i++)
{
TranslatePoint( v[i] );
}
pRender->DrawLine( v[0], v[1] );
pRender->DrawLine( v[1], v[2] );
pRender->DrawLine( v[2], v[3] );
pRender->DrawLine( v[3], v[0] );
}
pRender->PopRenderMode();
// draw a cross for translation origin in move or rotation mode
if ( IsTranslating() )
{
if ( m_TranslateMode == modeMove || m_TranslateMode == modeRotate )
{
Vector vec = m_vTranslationFixPoint;
if ( m_TranslateMode == modeMove )
{
TranslatePoint( vec );
}
// draw 'X'
pRender->SetHandleStyle( 7, CRender::HANDLE_CROSS );
pRender->SetHandleColor( GetRValue(Options.colors.clrToolDrag), GetGValue(Options.colors.clrToolDrag), GetBValue(Options.colors.clrToolDrag) );
pRender->DrawHandle( vec );
}
}
else if ( m_bEnableHandles )
{
RenderHandles2D( pRender, mins, maxs );
}
}
//-----------------------------------------------------------------------------
// Purpose: Renders this region as a wireframe box.
// Input : pRender - 3D Renderer.
//-----------------------------------------------------------------------------
void Box3D::RenderTool3D(CRender3D *pRender)
{
if ( IsTranslating() )
{
VMatrix matrix = GetTransformMatrix();
pRender->BeginLocalTransfrom( matrix );
}
else if (IsEmpty())
{
return;
}
pRender->PushRenderMode( RENDER_MODE_FLAT );
pRender->SetDrawColor( GetRValue(m_clrBox), GetGValue(m_clrBox), GetBValue(m_clrBox) );
pRender->DrawBox( bmins, bmaxs );
pRender->PopRenderMode();
if ( IsTranslating() )
{
pRender->EndLocalTransfrom();
if ( m_TranslateMode == modeMove || m_TranslateMode == modeRotate )
{
Vector vec = m_vTranslationFixPoint;
if ( m_TranslateMode == modeMove )
{
TranslatePoint( vec );
}
// draw 'X'
pRender->PushRenderMode( RENDER_MODE_FLAT_NOZ );
pRender->SetHandleStyle( 7, CRender::HANDLE_CROSS );
pRender->SetHandleColor( GetRValue(Options.colors.clrToolDrag), GetGValue(Options.colors.clrToolDrag), GetBValue(Options.colors.clrToolDrag) );
pRender->DrawHandle( vec );
pRender->PopRenderMode();
}
}
else if ( m_bEnableHandles )
{
RenderHandles3D( pRender, bmins, bmaxs );
};
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *vecStart -
// *mins -
// *maxs -
//-----------------------------------------------------------------------------
void Box3D::StartNew( CMapView *pView, const Vector2D &vPoint, const Vector &vecStart, const Vector &vecSize )
{
//Setup our info
m_TranslateMode = modeScale;
m_TranslateHandle = Vector( 1, 1, 1 );
bmins = vecStart;
bmaxs = vecStart+vecSize;
NormalizeBox( bmins, bmaxs );
StartTranslation( pView, vPoint, Vector( 1, 1, 1 ) );
m_bPreventOverlap = false;
m_bEmpty = false;
}
Reference in New Issue Copy Permalink