390 lines
12 KiB
C++
390 lines
12 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
//
|
|
//=============================================================================
|
|
|
|
#include <stdafx.h>
|
|
#include "MapEntity.h"
|
|
#include "MapOverlayTrans.h"
|
|
#include "DispShore.h"
|
|
#include "TextureSystem.h"
|
|
#include "ChunkFile.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CMapOverlayTransition::CMapOverlayTransition()
|
|
{
|
|
m_ShoreData.m_pTexture = NULL;
|
|
m_ShoreData.m_vecLengthTexcoord.Init();
|
|
m_ShoreData.m_vecWidthTexcoord.Init();
|
|
m_ShoreData.m_flWidths[0] = 0.0f;
|
|
m_ShoreData.m_flWidths[1] = 0.0f;
|
|
m_bIsWater = true;
|
|
m_aFaceCache1.Purge();
|
|
m_aFaceCache2.Purge();
|
|
m_bDebugDraw = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CMapOverlayTransition::~CMapOverlayTransition()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// NOTE: static
|
|
//-----------------------------------------------------------------------------
|
|
CMapClass *CMapOverlayTransition::Create( CHelperInfo *pInfo, CMapEntity *pParent )
|
|
{
|
|
CMapOverlayTransition *pOverlayTrans = new CMapOverlayTransition;
|
|
return pOverlayTrans;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called after the entire map has been loaded. This allows the object
|
|
// to perform any linking with other map objects or to do other operations
|
|
// that require all world objects to be present.
|
|
// Input : pWorld - The world that we are in.
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverlayTransition::PostloadWorld( CMapWorld *pWorld )
|
|
{
|
|
OnApply();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverlayTransition::CalcBounds( BOOL bFullUpdate )
|
|
{
|
|
CMapClass::CalcBounds( bFullUpdate );
|
|
|
|
Shoreline_t *pShoreline = GetShoreManager()->GetShoreline( ( int )GetParent() );
|
|
if ( pShoreline )
|
|
{
|
|
Vector vecMins( 99999.0f, 99999.0f, 99999.0f );
|
|
Vector vecMaxs( -99999.0f, -99999.0f, -99999.0f );
|
|
|
|
m_Render2DBox.ResetBounds();
|
|
m_CullBox.ResetBounds();
|
|
|
|
int nSegmentCount = pShoreline->m_aSegments.Count();
|
|
for ( int iSegment = 0; iSegment < nSegmentCount; ++iSegment )
|
|
{
|
|
for ( int iAxis = 0; iAxis < 3; ++iAxis )
|
|
{
|
|
if ( pShoreline->m_aSegments[iSegment].m_vecPoints[0][iAxis] < vecMins[iAxis] )
|
|
{
|
|
vecMins[iAxis] = pShoreline->m_aSegments[iSegment].m_vecPoints[0][iAxis];
|
|
}
|
|
|
|
if ( pShoreline->m_aSegments[iSegment].m_vecPoints[1][iAxis] < vecMins[iAxis] )
|
|
{
|
|
vecMins[iAxis] = pShoreline->m_aSegments[iSegment].m_vecPoints[1][iAxis];
|
|
}
|
|
|
|
if ( pShoreline->m_aSegments[iSegment].m_vecPoints[0][iAxis] > vecMaxs[iAxis] )
|
|
{
|
|
vecMaxs[iAxis] = pShoreline->m_aSegments[iSegment].m_vecPoints[0][iAxis];
|
|
}
|
|
|
|
if ( pShoreline->m_aSegments[iSegment].m_vecPoints[1][iAxis] > vecMaxs[iAxis] )
|
|
{
|
|
vecMaxs[iAxis] = pShoreline->m_aSegments[iSegment].m_vecPoints[1][iAxis];
|
|
}
|
|
}
|
|
}
|
|
|
|
m_Render2DBox.UpdateBounds( vecMins, vecMaxs );
|
|
m_CullBox = m_Render2DBox;
|
|
m_BoundingBox = m_CullBox;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CMapClass *CMapOverlayTransition::Copy( bool bUpdateDependencies )
|
|
{
|
|
CMapOverlayTransition *pCopy = new CMapOverlayTransition;
|
|
if ( pCopy )
|
|
{
|
|
pCopy->CopyFrom( this, bUpdateDependencies );
|
|
}
|
|
|
|
return pCopy;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CMapClass *CMapOverlayTransition::CopyFrom( CMapClass *pObject, bool bUpdateDependencies )
|
|
{
|
|
// Verify the object is of the correct type and cast.
|
|
Assert( pObject->IsMapClass( MAPCLASS_TYPE( CMapOverlayTransition ) ) );
|
|
CMapOverlayTransition *pFrom = ( CMapOverlayTransition* )pObject;
|
|
if ( pFrom )
|
|
{
|
|
m_ShoreData.m_pTexture = pFrom->m_ShoreData.m_pTexture;
|
|
m_ShoreData.m_vecLengthTexcoord = pFrom->m_ShoreData.m_vecLengthTexcoord;
|
|
m_ShoreData.m_vecWidthTexcoord = pFrom->m_ShoreData.m_vecWidthTexcoord;
|
|
m_ShoreData.m_flWidths[0] = pFrom->m_ShoreData.m_flWidths[0];
|
|
m_ShoreData.m_flWidths[1] = pFrom->m_ShoreData.m_flWidths[1];
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverlayTransition::OnParentKeyChanged( const char* szKey, const char* szValue )
|
|
{
|
|
// Material data.
|
|
if ( !stricmp( szKey, "material" ) )
|
|
{
|
|
IEditorTexture *pTex = g_Textures.FindActiveTexture( szValue );
|
|
if ( pTex )
|
|
{
|
|
m_ShoreData.m_pTexture = pTex;
|
|
}
|
|
}
|
|
|
|
// Texture data.
|
|
if ( !stricmp( szKey, "LengthTexcoordStart" ) )
|
|
{
|
|
m_ShoreData.m_vecLengthTexcoord[0] = atof( szValue );
|
|
}
|
|
if ( !stricmp( szKey, "LengthTexcoordEnd" ) )
|
|
{
|
|
m_ShoreData.m_vecLengthTexcoord[1] = atof( szValue );
|
|
}
|
|
if ( !stricmp( szKey, "WidthTexcoordStart" ) )
|
|
{
|
|
m_ShoreData.m_vecWidthTexcoord[0] = atof( szValue );
|
|
}
|
|
if ( !stricmp( szKey, "WidthTexcoordEnd" ) )
|
|
{
|
|
m_ShoreData.m_vecWidthTexcoord[1] = atof( szValue );
|
|
}
|
|
|
|
// Width data.
|
|
if ( !stricmp( szKey, "Width1" ) )
|
|
{
|
|
m_ShoreData.m_flWidths[0] = atof( szValue );
|
|
}
|
|
if ( !stricmp( szKey, "Width2" ) )
|
|
{
|
|
m_ShoreData.m_flWidths[1] = atof( szValue );
|
|
}
|
|
|
|
// Debug data.
|
|
if ( !stricmp( szKey, "DebugDraw" ) )
|
|
{
|
|
m_bDebugDraw = true;
|
|
if ( atoi( szValue ) == 0 )
|
|
{
|
|
m_bDebugDraw = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverlayTransition::OnNotifyDependent( CMapClass *pObject, Notify_Dependent_t eNotifyType )
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverlayTransition::OnAddToWorld( CMapWorld *pWorld )
|
|
{
|
|
OnApply();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverlayTransition::OnRemoveFromWorld( CMapWorld *pWorld, bool bNotifyChildren )
|
|
{
|
|
GetShoreManager()->RemoveShoreline( ( int )GetParent() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverlayTransition::OnUndoRedo( void )
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverlayTransition::DoTransform( const VMatrix& matrix )
|
|
{
|
|
return;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverlayTransition::OnPaste( CMapClass *pCopy, CMapWorld *pSourceWorld, CMapWorld *pDestWorld, const CMapObjectList &OriginalList, CMapObjectList &NewList)
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverlayTransition::OnClone( CMapClass *pClone, CMapWorld *pWorld, const CMapObjectList &OriginalList, CMapObjectList &NewList )
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMapOverlayTransition::Render3D( CRender3D *pRender )
|
|
{
|
|
GetShoreManager()->Draw( pRender );
|
|
if ( m_bDebugDraw )
|
|
{
|
|
GetShoreManager()->DebugDraw( pRender );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Generate a face list from the parent entities' side list child.
|
|
//-----------------------------------------------------------------------------
|
|
bool CMapOverlayTransition::BuildFaceCaches( void )
|
|
{
|
|
CMapEntity *pEntity = dynamic_cast<CMapEntity*>( GetParent() );
|
|
if ( pEntity )
|
|
{
|
|
const CMapObjectList *pChildren = pEntity->GetChildren();
|
|
FOR_EACH_OBJ( *pChildren, pos )
|
|
{
|
|
CMapSideList *pSideList = dynamic_cast<CMapSideList*>( pChildren->Element(pos) );
|
|
if ( pSideList )
|
|
{
|
|
// Check name.
|
|
if ( !stricmp( "sides" ,pSideList->GetKeyName() ) )
|
|
{
|
|
int nFaceCount = pSideList->GetFaceCount();
|
|
for ( int iFace = 0; iFace < nFaceCount; ++iFace )
|
|
{
|
|
m_aFaceCache1.AddToTail( pSideList->GetFace( iFace ) );
|
|
}
|
|
}
|
|
else if ( !stricmp( "sides2", pSideList->GetKeyName() ) )
|
|
{
|
|
int nFaceCount = pSideList->GetFaceCount();
|
|
for ( int iFace = 0; iFace < nFaceCount; ++iFace )
|
|
{
|
|
if ( m_bIsWater )
|
|
{
|
|
// Verify that the face is a water face.
|
|
if ( pSideList->GetFace( iFace )->GetTexture()->IsWater() )
|
|
{
|
|
m_aFaceCache2.AddToTail( pSideList->GetFace( iFace ) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_aFaceCache2.AddToTail( pSideList->GetFace( iFace ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ( ( m_aFaceCache1.Count() > 0 ) && ( m_aFaceCache2.Count() > 0 ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Create the transition overlays.
|
|
//-----------------------------------------------------------------------------
|
|
bool CMapOverlayTransition::OnApply( void )
|
|
{
|
|
if ( m_bIsWater )
|
|
{
|
|
// Create the shoreline.
|
|
if ( GetShoreManager()->Init() )
|
|
{
|
|
if ( BuildFaceCaches() )
|
|
{
|
|
m_nShorelineId = ( int )GetParent();
|
|
|
|
GetShoreManager()->AddShoreline( m_nShorelineId );
|
|
Shoreline_t *pShoreline = GetShoreManager()->GetShoreline( m_nShorelineId );
|
|
pShoreline->m_ShoreData = m_ShoreData;
|
|
|
|
GetShoreManager()->BuildShoreline( m_nShorelineId, m_aFaceCache1, m_aFaceCache2 );
|
|
|
|
// Clean up the face list.
|
|
m_aFaceCache1.Purge();
|
|
m_aFaceCache2.Purge();
|
|
}
|
|
|
|
GetShoreManager()->Shutdown();
|
|
}
|
|
|
|
// Post updated.
|
|
PostUpdate( Notify_Changed );
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// This part is not implemented yet!
|
|
return true;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
ChunkFileResult_t CMapOverlayTransition::LoadVMF( CChunkFile *pFile )
|
|
{
|
|
// This doesn't need to be implemented until we can "edit" the overlay data. For
|
|
// now just regenerate the data.
|
|
|
|
return ChunkFile_Ok;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
ChunkFileResult_t CMapOverlayTransition::SaveVMF( CChunkFile *pFile, CSaveInfo *pSaveInfo )
|
|
{
|
|
ChunkFileResult_t eResult = pFile->BeginChunk("overlaytransition");
|
|
|
|
m_nShorelineId = ( int )GetParent();
|
|
Shoreline_t *pShoreline = GetShoreManager()->GetShoreline( m_nShorelineId );
|
|
if ( pShoreline )
|
|
{
|
|
int nOverlayCount = pShoreline->m_aOverlays.Count();
|
|
for ( int iOverlay = 0; iOverlay < nOverlayCount; ++iOverlay )
|
|
{
|
|
CMapOverlay *pOverlay = &pShoreline->m_aOverlays[iOverlay];
|
|
if ( pOverlay )
|
|
{
|
|
pOverlay->SaveDataToVMF( pFile, pSaveInfo );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( eResult == ChunkFile_Ok )
|
|
{
|
|
eResult = pFile->EndChunk();
|
|
}
|
|
|
|
return eResult;
|
|
}
|