711 lines
22 KiB
C++
711 lines
22 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Rendering and mouse handling in the logical view.
|
|
//
|
|
//===========================================================================//
|
|
|
|
#include "stdafx.h"
|
|
#include "MapViewLogical.h"
|
|
#include "Render2D.h"
|
|
#include "MapWorld.h"
|
|
#include "TitleWnd.h"
|
|
#include "MapDoc.h"
|
|
#include "ToolManager.h"
|
|
#include "history.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
|
|
IMPLEMENT_DYNCREATE(CMapViewLogical, CMapView2DBase)
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CMapViewLogical, CMapView2DBase)
|
|
//{{AFX_MSG_MAP(CMapViewLogical)
|
|
ON_WM_TIMER()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Logical View Look and feel constants
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define LOGICAL_CONN_VERT_SPACING 100
|
|
#define LOGICAL_CONN_HORIZ_SPACING 20
|
|
#define LOGICAL_CONN_SPREAD_DIST 50
|
|
#define LOGICAL_CONN_TEXT_LENGTH 450
|
|
#define LOGICAL_CONN_CROSS_SIZE 30
|
|
#define LOGICAL_CONN_MULTI_CIRCLE_RADIUS 15
|
|
|
|
// Broken connection blinking interval (in ms)
|
|
#define TIMER_BLINK_INTERVAL 512
|
|
|
|
// Unselected and selected color values for the connections palette against the background color
|
|
|
|
#define DARK 112
|
|
#define MID 144
|
|
|
|
#define BACKGROUND 168
|
|
|
|
#define LITE 224
|
|
#define BRITE 255
|
|
|
|
#define LOGICAL_CONN_COLOR_COUNT 7
|
|
#define LOGICAL_CONN_SELECTION_STATES 2
|
|
|
|
static color32 s_pWireColors[LOGICAL_CONN_COLOR_COUNT][LOGICAL_CONN_SELECTION_STATES] =
|
|
{
|
|
{ { MID, MID, 0, 255 }, /* Mid Yellow */ { BRITE, BRITE, 0, 255 }, /* Bright Yellow */ },
|
|
{ { MID, DARK, 0, 255 }, /* Dark Orange */ { BRITE, MID, 0, 255 }, /* Bright Orange */ },
|
|
{ { 0, DARK, 0, 255 }, /* Dark Green */ { 0, BRITE, 0, 255 }, /* Bright Green */ },
|
|
{ { 0, MID, MID, 255 }, /* Mid Cyan */ { 0, BRITE, BRITE, 255 }, /* Bright Cyan */ },
|
|
{ { 0, 0, MID, 255 }, /* Mid Blue */ { 0, MID, BRITE, 255 }, /* Bright Baby Blue */ },
|
|
{ { MID, 0, MID, 255 }, /* Mid Magenta */ { BRITE, 0, BRITE, 255 }, /* Bright Magenta */ },
|
|
{ { DARK, DARK, DARK, 255 }, /* Dark Gray */ { BRITE, BRITE, BRITE, 255 }, /* Bright White */ },
|
|
};
|
|
|
|
static color32 s_pBrokenWireColor[LOGICAL_CONN_SELECTION_STATES] =
|
|
{
|
|
{ DARK, 0, 0, 255 }, /* Dark Red */ { BRITE, 0, 0, 255 }, /* Bright Red */
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor. Initializes data members.
|
|
// ---------------------------------------------------------------------------
|
|
CMapViewLogical::CMapViewLogical(void) : m_RenderDict( 0, 1024, DefLessFunc( CMapClass* ) )
|
|
{
|
|
m_bUpdateRenderObjects = true;
|
|
SetAxes(AXIS_X, FALSE, AXIS_Y, TRUE);
|
|
SetDrawType( VIEW_LOGICAL );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor. Frees dynamically allocated resources.
|
|
//-----------------------------------------------------------------------------
|
|
CMapViewLogical::~CMapViewLogical(void)
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: First-time initialization of this view.
|
|
//-----------------------------------------------------------------------------
|
|
void CMapViewLogical::OnInitialUpdate(void)
|
|
{
|
|
CreateTitleWindow();
|
|
GetTitleWnd()->SetTitle("Logical");
|
|
SetZoom(0); // Zoom out as far as possible.
|
|
UpdateClientView();
|
|
CMapView2DBase::OnInitialUpdate();
|
|
// FIXME: Hardcoded light gray background - should be from a new "Logical View" options settings dialog
|
|
m_ClearColor.SetColor( BACKGROUND, BACKGROUND, BACKGROUND, 255 );
|
|
m_clrGrid.SetColor( MID, MID, MID, 255 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : point - Point in client coordinates.
|
|
// bMakeFirst -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CMapViewLogical::SelectAtCascading( const Vector2D &ptClient, bool bMakeFirst )
|
|
{
|
|
CMapDoc *pDoc = GetMapDoc();
|
|
CSelection *pSelection = pDoc->GetSelection();
|
|
|
|
pSelection->ClearHitList();
|
|
|
|
GetHistory()->MarkUndoPosition(pSelection->GetList(), "Selection");
|
|
|
|
//
|
|
// Check all the objects in the world for a hit at this point.
|
|
//
|
|
|
|
HitInfo_t HitData[MAX_PICK_HITS];
|
|
int nHits = ObjectsAt(ptClient, HitData, MAX_PICK_HITS);
|
|
|
|
// If there were no hits at the given point, clear selection.
|
|
if ( nHits == 0 )
|
|
{
|
|
if (bMakeFirst)
|
|
{
|
|
pDoc->SelectFace(NULL, 0, scClear|scSaveChanges);
|
|
pDoc->SelectObject(NULL, scClear|scSaveChanges);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
SelectMode_t eSelectMode = pSelection->GetMode();
|
|
|
|
for ( int i=0; i<nHits; ++i )
|
|
{
|
|
CMapClass *pSelObject = HitData[i].pObject->PrepareSelection( eSelectMode );
|
|
if ( !pSelObject )
|
|
continue;
|
|
|
|
pSelection->AddHit( pSelObject );
|
|
}
|
|
|
|
//
|
|
// Select a single object.
|
|
//
|
|
if ( bMakeFirst )
|
|
{
|
|
pDoc->SelectFace( NULL, 0, scClear|scSaveChanges );
|
|
pDoc->SelectObject( NULL, scClear|scSaveChanges );
|
|
}
|
|
|
|
pSelection->SetCurrentHit( hitFirst, true );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Base class calls this when render lists need rebuilding
|
|
//-----------------------------------------------------------------------------
|
|
void CMapViewLogical::OnRenderListDirty()
|
|
{
|
|
m_bUpdateRenderObjects = true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Builds up list of mapclasses to render
|
|
//-----------------------------------------------------------------------------
|
|
void CMapViewLogical::AddToRenderLists( CMapClass *pObject )
|
|
{
|
|
#if _DEBUG && 0
|
|
CMapEntity *pEntity = dynamic_cast<CMapEntity *>(pObject);
|
|
if (pEntity)
|
|
{
|
|
LPCTSTR pszTargetName = pEntity->GetKeyValue("targetname");
|
|
if ( pszTargetName && !strcmp(pszTargetName, "relay_cancelVCDs") )
|
|
{
|
|
// Set breakpoint here for debugging this entity's visiblity
|
|
int foo = 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if ( !pObject->IsVisibleLogical() )
|
|
return;
|
|
|
|
// Don't render groups, render their children instead.
|
|
if ( !pObject->IsGroup() && pObject->IsLogical() )
|
|
{
|
|
Vector2D vecMins, vecMaxs;
|
|
pObject->GetRenderLogicalBox( vecMins, vecMaxs );
|
|
|
|
// Always paint all the entities to ensure that any inter-entity connections are visible
|
|
// if ( !IsValidBox( vecMins, vecMaxs ) || IsInClientView( vecMins, vecMaxs ) )
|
|
{
|
|
// Make sure the object is in the update region.
|
|
m_RenderList.AddToTail( pObject );
|
|
m_ConnectionList.AddToTail( pObject );
|
|
m_RenderDict.Insert( pObject );
|
|
}
|
|
}
|
|
|
|
// Recurse into children and add them.
|
|
const CMapObjectList *pChildren = pObject->GetChildren();
|
|
FOR_EACH_OBJ( *pChildren, pos )
|
|
{
|
|
AddToRenderLists( pChildren->Element(pos) );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Builds up list of mapclasses to render
|
|
//-----------------------------------------------------------------------------
|
|
void CMapViewLogical::PopulateConnectionList( )
|
|
{
|
|
while ( m_ConnectionUpdate.Count() )
|
|
{
|
|
CMapClass *pObject;
|
|
m_ConnectionUpdate.Pop( pObject );
|
|
if ( !pObject->IsVisibleLogical() )
|
|
continue;
|
|
|
|
// Don't render groups, render their children instead.
|
|
if ( !pObject->IsGroup() && pObject->IsLogical() )
|
|
{
|
|
// Don't add it if it's visible already
|
|
if ( m_RenderDict.Find( pObject ) == m_RenderDict.InvalidIndex() )
|
|
{
|
|
CEditGameClass *pClass = dynamic_cast< CEditGameClass * >( pObject );
|
|
if ( pClass )
|
|
{
|
|
int nCount = pClass->Connections_GetCount();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
CEntityConnection *pConn = pClass->Connections_Get( i );
|
|
|
|
// Find the input entity associated with this connection
|
|
CMapEntityList *pEntityList = pConn->GetTargetEntityList();
|
|
|
|
int j;
|
|
int nInputCount = pEntityList->Count();
|
|
for ( j = 0; j < nInputCount; ++j )
|
|
{
|
|
CMapEntity *pEntity = pEntityList->Element(j);
|
|
if ( m_RenderDict.Find( pEntity ) != m_RenderDict.InvalidIndex() )
|
|
{
|
|
m_ConnectionList.AddToTail( pObject );
|
|
break;
|
|
}
|
|
}
|
|
if ( j != nInputCount )
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Recurse into children and add them.
|
|
const CMapObjectList *pChildren = pObject->GetChildren();
|
|
FOR_EACH_OBJ( *pChildren, pos )
|
|
{
|
|
m_ConnectionUpdate.Push( pChildren->Element(pos) );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : nIDEvent -
|
|
//-----------------------------------------------------------------------------
|
|
void CMapViewLogical::OnTimer(UINT nIDEvent)
|
|
{
|
|
if ( nIDEvent == TIMER_CONNECTIONUPDATE )
|
|
{
|
|
// Make sure we don't blink too fast
|
|
static unsigned int nLastUpdate = 0;
|
|
if ( GetTickCount() >= (nLastUpdate+TIMER_BLINK_INTERVAL/2) )
|
|
{
|
|
nLastUpdate = GetTickCount();
|
|
UpdateView( 0 ); // Force the view to redraw for blinking errors
|
|
}
|
|
}
|
|
else
|
|
CView::OnTimer(nIDEvent);
|
|
}
|
|
|
|
|
|
const color32 & CMapViewLogical::GetWireColor(const char *pszName, const bool bSelected, const bool bError, const bool bAnySelected)
|
|
{
|
|
// Select the connecting color based on the string passed in
|
|
// (using OutputName for instance, gives varying "wire colors" by entity output type).
|
|
|
|
Assert( LOGICAL_CONN_COLOR_COUNT == (sizeof(s_pWireColors) / sizeof(color32) ) / LOGICAL_CONN_SELECTION_STATES );
|
|
|
|
if ( !bError )
|
|
{
|
|
|
|
int nIndex = 0;
|
|
|
|
// Has the named passed in
|
|
while ( *pszName )
|
|
nIndex += *pszName++;
|
|
|
|
// Index based on the number of colors available
|
|
nIndex %= LOGICAL_CONN_COLOR_COUNT;
|
|
|
|
// Only blink non-errors if the drawing object is selected
|
|
// bool bBlinkingState = bSelected ? (GetTickCount() / TIMER_BLINK_INTERVAL) & 1 : 0;
|
|
return s_pWireColors[nIndex][bSelected];
|
|
}
|
|
else
|
|
{
|
|
// Only blink errors if nothing is selected, or this is selected
|
|
bool bBlinkingState = bSelected || !bAnySelected ? (GetTickCount() / TIMER_BLINK_INTERVAL) & 1 : bSelected;
|
|
return s_pBrokenWireColor[bBlinkingState];
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Draws a wire from a particular point to a target
|
|
//-----------------------------------------------------------------------------
|
|
#define BACKWARD_WIRE_OVERSHOOT 50
|
|
#define BACKWARD_WIRE_Y_DISTANCE 150
|
|
|
|
void CMapViewLogical::DrawConnectingWire( float x, float y, CMapEntity *pSource, CEntityConnection *pConnection, CMapEntity *pTarget )
|
|
{
|
|
CRender2D *pRender = GetRender();
|
|
|
|
// FIXME: Deal with bad input type
|
|
Vector2D vecEndPosition, vecConnector;
|
|
pTarget->GetLogicalConnectionPosition( LOGICAL_CONNECTION_INPUT, vecConnector );
|
|
vecEndPosition = vecConnector;
|
|
|
|
int nInputs = pTarget->Upstream_GetCount();
|
|
|
|
// Compensate for multiple inputs -- fan-in the connections from the various pSource entities
|
|
BOOL bFound = false;
|
|
if ( nInputs )
|
|
{
|
|
int nInput;
|
|
for ( nInput = 0; nInput < nInputs; nInput++ )
|
|
{
|
|
CEntityConnection *pInputConnection = pTarget->Upstream_Get(nInput);
|
|
if ( pInputConnection )
|
|
{
|
|
if ( pInputConnection == pConnection )
|
|
{
|
|
bFound = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (bFound)
|
|
{
|
|
vecEndPosition.x -= LOGICAL_CONN_SPREAD_DIST;
|
|
vecEndPosition.y += ( (nInputs - 1) * LOGICAL_CONN_VERT_SPACING / 2 ) / 2 - (nInput * LOGICAL_CONN_VERT_SPACING / 2);
|
|
|
|
pRender->MoveTo( Vector( vecEndPosition.x, vecEndPosition.y, 0.0f) );
|
|
pRender->DrawLineTo( Vector( vecConnector.x, vecConnector.y, 0.0f) );
|
|
}
|
|
else
|
|
{
|
|
Assert(0);
|
|
}
|
|
}
|
|
|
|
pRender->MoveTo( Vector( x, y, 0.0f ) );
|
|
if ( x < vecEndPosition.x )
|
|
{
|
|
// Do direct connection
|
|
pRender->DrawLineTo( Vector( x, vecEndPosition.y, 0.0f ) );
|
|
pRender->DrawLineTo( Vector( vecEndPosition.x, vecEndPosition.y, 0.0f ) );
|
|
return;
|
|
}
|
|
|
|
Vector2D vecTargetMins, vecTargetMaxs;
|
|
pTarget->GetRenderLogicalBox( vecTargetMins, vecTargetMaxs );
|
|
vecTargetMins.y -= BACKWARD_WIRE_Y_DISTANCE;
|
|
vecTargetMaxs.y += BACKWARD_WIRE_Y_DISTANCE;
|
|
|
|
float flHalfY = ( y + vecEndPosition.y ) * 0.5f;
|
|
if ( flHalfY > vecTargetMins.y && flHalfY < vecTargetMaxs.y )
|
|
{
|
|
flHalfY = ( flHalfY < vecEndPosition.y ) ? vecTargetMins.y : vecTargetMaxs.y;
|
|
}
|
|
|
|
pRender->DrawLineTo( Vector( x, flHalfY, 0.0f ) );
|
|
pRender->DrawLineTo( Vector( vecEndPosition.x - BACKWARD_WIRE_OVERSHOOT, flHalfY, 0.0f ) );
|
|
pRender->DrawLineTo( Vector( vecEndPosition.x - BACKWARD_WIRE_OVERSHOOT, vecEndPosition.y, 0.0f ) );
|
|
pRender->DrawLineTo( Vector( vecEndPosition.x, vecEndPosition.y, 0.0f ) );
|
|
}
|
|
|
|
void CMapViewLogical::RenderConnections(const bool bDrawSelected, const bool bAnySelected)
|
|
{
|
|
Vector2D pt, pt2;
|
|
WorldToClient( pt, Vector( 0.0f, 0.0f, 0.0f ) );
|
|
WorldToClient( pt2, Vector( 0.0f, LOGICAL_CONN_VERT_SPACING, 0.0f ) );
|
|
|
|
int nCount = m_ConnectionList.Count();
|
|
|
|
for ( int i = 0; i < nCount ; ++i )
|
|
{
|
|
CMapEntity *pMapClass = dynamic_cast<CMapEntity*>( m_ConnectionList[i] );
|
|
if ( !pMapClass )
|
|
continue;
|
|
|
|
CEditGameClass *pEditClass = dynamic_cast<CEditGameClass*>( pMapClass );
|
|
if ( !pEditClass )
|
|
continue;
|
|
|
|
int nConnectionCount = pEditClass->Connections_GetCount();
|
|
if ( nConnectionCount == 0 )
|
|
continue;
|
|
|
|
Vector2D vecStartPosition;
|
|
pMapClass->GetLogicalConnectionPosition( LOGICAL_CONNECTION_OUTPUT, vecStartPosition );
|
|
|
|
CRender2D *pRender = GetRender();
|
|
|
|
float x = vecStartPosition.x + LOGICAL_CONN_SPREAD_DIST + LOGICAL_CONN_TEXT_LENGTH;
|
|
float y = vecStartPosition.y + ( nConnectionCount - 1 ) * LOGICAL_CONN_VERT_SPACING / 2;
|
|
|
|
for ( int j = 0; j < nConnectionCount; ++j )
|
|
{
|
|
CEntityConnection *pConn = pEditClass->Connections_Get( j );
|
|
|
|
// Find the input entity associated with this connection
|
|
CMapEntityList *pEntityList = pConn->GetTargetEntityList();
|
|
int nInputCount = pEntityList->Count();
|
|
bool bBadInput = !MapEntityList_HasInput( pEntityList, pConn->GetInputName() );
|
|
bool bBadConnection = (nInputCount == 0);
|
|
|
|
// Stop drawing entity connection text once the entity itself gets too small.
|
|
bool bDrawOutput = ( fabs( pt.y - pt2.y ) >= 16 );
|
|
bool bDrawDelay = ( fabs( pt.y - pt2.y ) >= 20 );
|
|
bool bDrawInput = ( fabs( pt.y - pt2.y ) >= 24 );
|
|
bool bDrawTarget = ( fabs( pt.y - pt2.y ) >= 28 );
|
|
|
|
bool bEntitySelected = ( pMapClass->GetSelectionState() != SELECT_NONE );
|
|
bool bInputSelected = false;
|
|
|
|
for ( int k = 0; k < nInputCount; ++k )
|
|
{
|
|
if ( pEntityList->Element( k )->GetSelectionState() != SELECT_NONE )
|
|
bInputSelected = true;
|
|
|
|
// Make sure all the connected entities are all visible
|
|
if ( pEntityList->Element( k )->IsVisibleLogical() == false )
|
|
bBadConnection = true;
|
|
}
|
|
|
|
// Make sure we only draw the selected OR unselected connections as requested
|
|
if ( bDrawSelected == (bEntitySelected || bInputSelected) )
|
|
{
|
|
color32 c = GetWireColor( pConn->GetOutputName(),
|
|
bEntitySelected || bInputSelected,
|
|
bBadConnection || bBadInput,
|
|
bAnySelected );
|
|
|
|
if ( bDrawDelay || bDrawOutput || bDrawInput || bDrawTarget )
|
|
{
|
|
char pBuf[1024];
|
|
|
|
pRender->SetTextColor( c.r, c.g, c.b );
|
|
|
|
int nChars = 0;
|
|
if ( bDrawOutput )
|
|
nChars += Q_snprintf( pBuf+nChars, sizeof(pBuf), "%s", pConn->GetOutputName() );
|
|
if ( bDrawDelay )
|
|
nChars += Q_snprintf( pBuf+nChars, sizeof(pBuf), "(%.2f)", pConn->GetDelay() );
|
|
|
|
if ( nChars )
|
|
pRender->DrawText( pBuf, Vector2D( vecStartPosition.x + LOGICAL_CONN_SPREAD_DIST, y ), 2, 1, CRender2D::TEXT_JUSTIFY_TOP | CRender2D::TEXT_JUSTIFY_RIGHT );
|
|
|
|
nChars = 0;
|
|
if ( bDrawInput )
|
|
nChars += Q_snprintf( pBuf+nChars, sizeof(pBuf), "%s", pConn->GetInputName() );
|
|
if ( bDrawTarget )
|
|
nChars += Q_snprintf( pBuf+nChars, sizeof(pBuf), "[%s] ", pConn->GetTargetName() );
|
|
|
|
if ( nChars )
|
|
pRender->DrawText( pBuf, Vector2D( vecStartPosition.x + LOGICAL_CONN_SPREAD_DIST, y ), 2, -1, CRender2D::TEXT_JUSTIFY_BOTTOM | CRender2D::TEXT_JUSTIFY_RIGHT );
|
|
}
|
|
|
|
pRender->SetDrawColor( c.r, c.g, c.b );
|
|
pRender->MoveTo( Vector( vecStartPosition.x, vecStartPosition.y, 0.0f ) );
|
|
pRender->DrawLineTo( Vector( vecStartPosition.x + LOGICAL_CONN_SPREAD_DIST, y, 0.0f ) );
|
|
pRender->DrawLineTo( Vector( x, y, 0.0f ) );
|
|
|
|
if ( bBadConnection )
|
|
{
|
|
// Draw an X for a bogus connection.
|
|
pRender->MoveTo( Vector( x - LOGICAL_CONN_CROSS_SIZE, y - LOGICAL_CONN_CROSS_SIZE, 0.0f ) );
|
|
pRender->DrawLineTo( Vector( x + LOGICAL_CONN_CROSS_SIZE, y + LOGICAL_CONN_CROSS_SIZE, 0.0f ) );
|
|
pRender->MoveTo( Vector( x - LOGICAL_CONN_CROSS_SIZE, y + LOGICAL_CONN_CROSS_SIZE, 0.0f ) );
|
|
pRender->DrawLineTo( Vector( x + LOGICAL_CONN_CROSS_SIZE, y - LOGICAL_CONN_CROSS_SIZE, 0.0f ) );
|
|
}
|
|
else if ( nInputCount == 1 )
|
|
{
|
|
DrawConnectingWire( x, y, pMapClass, pConn, pEntityList->Element( 0 ) );
|
|
}
|
|
else
|
|
{
|
|
// Draw a circle for multiple connections
|
|
pRender->DrawCircle( Vector( x + LOGICAL_CONN_MULTI_CIRCLE_RADIUS, y, 0.0f ), LOGICAL_CONN_MULTI_CIRCLE_RADIUS );
|
|
|
|
float mx = x + LOGICAL_CONN_SPREAD_DIST;
|
|
float my = y + ( nInputCount / 2 ) * LOGICAL_CONN_VERT_SPACING/2;
|
|
|
|
Vector vecStart( x + LOGICAL_CONN_MULTI_CIRCLE_RADIUS, y, 0.0f );
|
|
for ( int k = 0; k < nInputCount; ++k )
|
|
{
|
|
// bBadInput = false; // This should be based on whether downstream entity has the specificied named input
|
|
bInputSelected = ( pEntityList->Element( k )->GetSelectionState() != SELECT_NONE );
|
|
color32 col = GetWireColor( pConn->GetOutputName(),
|
|
bEntitySelected || bInputSelected,
|
|
bBadInput,
|
|
bAnySelected );
|
|
|
|
pRender->SetDrawColor( col.r, col.g, col.b );
|
|
|
|
Vector vecEnd( mx, my, 0.0f );
|
|
Vector vecDelta;
|
|
VectorSubtract( vecEnd, vecStart, vecDelta );
|
|
VectorNormalize( vecDelta );
|
|
vecDelta *= LOGICAL_CONN_MULTI_CIRCLE_RADIUS;
|
|
vecDelta += vecStart;
|
|
|
|
pRender->MoveTo( vecDelta );
|
|
pRender->DrawLineTo( Vector( mx, my, 0.0f ) );
|
|
DrawConnectingWire( mx, my, pMapClass, pConn, pEntityList->Element( k ) );
|
|
|
|
mx += LOGICAL_CONN_HORIZ_SPACING;
|
|
my -= LOGICAL_CONN_VERT_SPACING/2;
|
|
}
|
|
}
|
|
}
|
|
|
|
x += LOGICAL_CONN_HORIZ_SPACING * (nInputCount+1) + 2*LOGICAL_CONN_MULTI_CIRCLE_RADIUS;
|
|
y -= LOGICAL_CONN_VERT_SPACING;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapViewLogical::Render()
|
|
{
|
|
CMapDoc *pDoc = GetMapDoc();
|
|
CMapWorld *pWorld = pDoc->GetMapWorld();
|
|
|
|
GetRender()->StartRenderFrame();
|
|
|
|
// Draw grid if enabled.
|
|
if ( pDoc->m_bShowLogicalGrid )
|
|
{
|
|
DrawGridLogical( GetRender() );
|
|
}
|
|
|
|
// Draw the world if we have one.
|
|
if (pWorld == NULL)
|
|
return;
|
|
|
|
// Traverse the entire world, sorting visible elements into two arrays:
|
|
// Normal objects and selected objects, so that we can render the selected
|
|
// objects last.
|
|
if ( m_bUpdateRenderObjects )
|
|
{
|
|
m_bUpdateRenderObjects = false;
|
|
|
|
m_RenderList.RemoveAll();
|
|
m_RenderDict.RemoveAll();
|
|
m_ConnectionList.RemoveAll();
|
|
m_ConnectionUpdate.Clear();
|
|
|
|
// fill render lists with visible objects
|
|
AddToRenderLists( pWorld );
|
|
|
|
// Add the connections too
|
|
m_ConnectionUpdate.Push( pWorld );
|
|
PopulateConnectionList();
|
|
|
|
// Make sure we have a timer running to drive error animations
|
|
SetTimer( TIMER_CONNECTIONUPDATE, TIMER_BLINK_INTERVAL, NULL);
|
|
}
|
|
|
|
// Assume we are blinking, unless something is selected.
|
|
bool bAnySelected = FALSE;
|
|
|
|
CUtlVector<CMapClass *> selectedObjects;
|
|
CUtlVector<CMapClass *> helperObjects;
|
|
CUtlVector<CMapClass *> unselectedObjects;
|
|
|
|
// Render normal (nonselected) objects first
|
|
for (int i = 0; i < m_RenderList.Count(); i++)
|
|
{
|
|
CMapClass *pObject = m_RenderList[i];
|
|
|
|
if ( pObject->IsSelected() )
|
|
{
|
|
bAnySelected = TRUE;
|
|
|
|
// render later
|
|
if ( pObject->GetToolObject( 0, false ) )
|
|
{
|
|
helperObjects.AddToTail( pObject );
|
|
}
|
|
else
|
|
{
|
|
selectedObjects.AddToTail( pObject );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
unselectedObjects.AddToTail( pObject );
|
|
}
|
|
}
|
|
|
|
// Render unselected connections first
|
|
RenderConnections(false, bAnySelected);
|
|
|
|
// render unselected objects next, on top of the connections
|
|
for ( int j = 0; j < unselectedObjects.Count(); j++ )
|
|
{
|
|
unselectedObjects[j]->RenderLogical( GetRender() );
|
|
}
|
|
|
|
if ( bAnySelected )
|
|
{
|
|
// Render selected objects in second batch, so they overdraw normal object
|
|
for (int i = 0; i < selectedObjects.Count(); i++)
|
|
{
|
|
selectedObjects[i]->RenderLogical( GetRender() );
|
|
}
|
|
|
|
// Render selected connections on top of everything else
|
|
RenderConnections(true, bAnySelected);
|
|
}
|
|
|
|
// render all tools
|
|
CBaseTool *pCurTool = pDoc->GetTools()->GetActiveTool();
|
|
|
|
int nToolCount = pDoc->GetTools()->GetToolCount();
|
|
for (int i = 0; i < nToolCount; i++)
|
|
{
|
|
CBaseTool *pTool = pDoc->GetTools()->GetTool(i);
|
|
if ((pTool != NULL) && (pTool != pCurTool))
|
|
{
|
|
pTool->RenderToolLogical( GetRender() );
|
|
}
|
|
}
|
|
|
|
// render active tool over all other tools
|
|
if ( pCurTool )
|
|
{
|
|
pCurTool->RenderToolLogical( GetRender() );
|
|
}
|
|
|
|
// render map helpers at last
|
|
for (int i = 0; i < helperObjects.Count(); i++)
|
|
{
|
|
helperObjects[i]->RenderLogical( GetRender() );
|
|
}
|
|
|
|
GetRender()->EndRenderFrame();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// convert client view space to map world coordinates (2D versions for convenience)
|
|
//-----------------------------------------------------------------------------
|
|
void CMapViewLogical::WorldToClient( Vector2D &ptClient, const Vector2D &vWorld )
|
|
{
|
|
Vector vWorld3D( vWorld.x, vWorld.y, 0.0f );
|
|
CMapView2DBase::WorldToClient( ptClient, vWorld3D );
|
|
}
|
|
|
|
void CMapViewLogical::ClientToWorld( Vector2D &vWorld, const Vector2D &vClient )
|
|
{
|
|
Vector vWorld3D;
|
|
CMapView2DBase::ClientToWorld( vWorld3D, vClient );
|
|
vWorld.x = vWorld3D.x;
|
|
vWorld.y = vWorld3D.y;
|
|
}
|
|
|
|
void CMapViewLogical::WorldToClient( Vector2D &ptClient, const Vector &vWorld )
|
|
{
|
|
CMapView2DBase::WorldToClient( ptClient, vWorld );
|
|
}
|
|
|
|
void CMapViewLogical::ClientToWorld( Vector &vWorld, const Vector2D &vClient )
|
|
{
|
|
CMapView2DBase::ClientToWorld( vWorld, vClient );
|
|
}
|