source-engine-2018-hl2_src/tools/toolutils/miniviewport.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================

#include "toolutils/miniviewport.h"
#include "tier1/utlstring.h"
#include "vgui/ISurface.h"
#include "materialsystem/imaterialsystemhardwareconfig.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/MaterialSystemUtil.h"
#include "materialsystem/imesh.h"
#include "materialsystem/imaterial.h"
#include "materialsystem/itexture.h"
#include "tier1/KeyValues.h"
#include "toolframework/ienginetool.h"
#include "toolutils/enginetools_int.h"
#include "VGuiMatSurface/IMatSystemSurface.h"
#include "view_shared.h"
#include "texture_group_names.h"
#include "vgui_controls/PropertySheet.h"
#include "tier2/tier2.h"
#include <windows.h>	// for MultiByteToWideChar
#include "cdll_int.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

class CMiniViewportEngineRenderArea;

using namespace vgui;

extern IMatSystemSurface *g_pMatSystemSurface;

#define DEFAULT_PREVIEW_WIDTH 1280

//-----------------------------------------------------------------------------
// Purpose: This is a "frame" which is used to position the engine
//-----------------------------------------------------------------------------
class CMiniViewportPropertyPage : public vgui::EditablePanel
{
	DECLARE_CLASS_SIMPLE( CMiniViewportPropertyPage, vgui::EditablePanel );

public:
	CMiniViewportPropertyPage( Panel *parent, const char *panelName );

	virtual Color GetBgColor();

	void	GetEngineBounds( int& x, int& y, int& w, int& h );

	void	RenderFrameBegin();

	CMiniViewportEngineRenderArea *GetViewportArea() { return m_pViewportArea; }

private:
	virtual void PerformLayout();

	Color	m_bgColor;

	CMiniViewportEngineRenderArea				*m_pViewportArea;
};

//-----------------------------------------------------------------------------
//
// the actual renderable area
//
//-----------------------------------------------------------------------------
class CMiniViewportEngineRenderArea : public vgui::EditablePanel
{
	DECLARE_CLASS_SIMPLE( CMiniViewportEngineRenderArea, vgui::EditablePanel );

public:
	CMiniViewportEngineRenderArea( Panel *parent, const char *panelName );
	~CMiniViewportEngineRenderArea();

	virtual void PaintBackground();
	virtual void GetEngineBounds( int& x, int& y, int& w, int& h );
	virtual void ApplySchemeSettings( IScheme *pScheme );

	void	RenderFrameBegin();
	void	SetOverlayText( const char *pText );

	// Called when the layoff texture needs to be released
	void ReleaseLayoffTexture();

protected:
	void			InitSceneMaterials();
	void			ShutdownSceneMaterials();

	// Paints the black borders around the engine window
	void PaintEngineBorders( int x, int y, int w, int h );

	// Paints the engine window	itself
	void PaintEngineWindow( int x, int y, int w, int h );

	// Paints the overlay text
	void PaintOverlayText( );

	int m_nEngineOutputTexture;
	vgui::HFont	m_OverlayTextFont;
	CUtlString m_OverlayText;

	CTextureReference			m_ScreenBuffer;	
	CMaterialReference			m_ScreenMaterial;
};


CMiniViewportEngineRenderArea::CMiniViewportEngineRenderArea( Panel *parent, const char *panelName )
	: BaseClass( parent, panelName )
{
	SetPaintEnabled( false );
	SetPaintBorderEnabled( false );
	SetPaintBackgroundEnabled( true );

	m_nEngineOutputTexture = vgui::surface()->CreateNewTextureID();
}

CMiniViewportEngineRenderArea::~CMiniViewportEngineRenderArea()
{
	ShutdownSceneMaterials();
}

void CMiniViewportEngineRenderArea::RenderFrameBegin()
{
	if ( !enginetools->IsInGame() )
		return;

	InitSceneMaterials();

	CViewSetup playerViewSetup;
	int x, y, w, h;
	GetEngineBounds( x, y, w, h );
	enginetools->GetPlayerView( playerViewSetup, 0, 0, w, h );

	// NOTE: This is a workaround to a nasty problem. Vgui uses stencil
	// to determing if the panels should occlude each other. The engine
	// has now started to use stencil for various random effects.
	// To prevent these different stencil uses from clashing, we will
	// render the engine prior to vgui painting + cache the result off in
	// 
	// Make the engine draw the scene
	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
	pRenderContext->PushRenderTargetAndViewport( m_ScreenBuffer, 0, 0, w, h );

	// Tell the engine to tell the client to render the view (sans viewmodel)
	enginetools->SetMainView( playerViewSetup.origin, playerViewSetup.angles );
	enginetools->RenderView( playerViewSetup, VIEW_CLEAR_COLOR | VIEW_CLEAR_DEPTH, RENDERVIEW_DRAWHUD | RENDERVIEW_DRAWVIEWMODEL );

	// Pop the target
	pRenderContext->PopRenderTargetAndViewport();
}

void CMiniViewportEngineRenderArea::InitSceneMaterials()
{
	if ( m_ScreenBuffer )
		return;

	if ( g_pMaterialSystem->IsTextureLoaded( "_rt_LayoffResult"	) ) 
	{
		ITexture *pTexture = g_pMaterialSystem->FindTexture( "_rt_LayoffResult", TEXTURE_GROUP_RENDER_TARGET );
		m_ScreenBuffer.Init( pTexture );
	}
	else
	{
		// For now, layoff dimensions match aspect of back buffer
		int nBackBufferWidth, nBackBufferHeight;
		g_pMaterialSystem->GetBackBufferDimensions( nBackBufferWidth, nBackBufferHeight );
		float flAspect = nBackBufferWidth / (float)nBackBufferHeight;
		int nPreviewWidth = min( DEFAULT_PREVIEW_WIDTH, nBackBufferWidth );
		int nPreviewHeight = ( int )( nPreviewWidth / flAspect + 0.5f );

		g_pMaterialSystem->BeginRenderTargetAllocation();								// Begin allocating RTs which IFM can scribble into

		// LDR final result of either HDR or LDR rendering
		m_ScreenBuffer.Init( g_pMaterialSystem->CreateNamedRenderTargetTextureEx2(
			"_rt_LayoffResult", nPreviewWidth, nPreviewHeight, RT_SIZE_OFFSCREEN,
			g_pMaterialSystem->GetBackBufferFormat(), MATERIAL_RT_DEPTH_SHARED, TEXTUREFLAGS_BORDER ) );

		g_pMaterialSystem->EndRenderTargetAllocation();									// End allocating RTs which IFM can scribble into
	}

	KeyValues *pVMTKeyValues = NULL;
	pVMTKeyValues= new KeyValues( "UnlitGeneric" );
	pVMTKeyValues->SetString( "$basetexture", m_ScreenBuffer->GetName() );
	pVMTKeyValues->SetInt( "$nofog", 1 );
	m_ScreenMaterial.Init( "MiniViewportEngineRenderAreaSceneMaterial", pVMTKeyValues );
	m_ScreenMaterial->Refresh();
}


//-----------------------------------------------------------------------------
// Called when the layoff texture needs to be released
//-----------------------------------------------------------------------------
void CMiniViewportEngineRenderArea::ReleaseLayoffTexture()
{
	m_ScreenBuffer.Shutdown();
	m_ScreenMaterial.Shutdown();
}


//-----------------------------------------------------------------------------
// Apply scheme settings
//-----------------------------------------------------------------------------
void CMiniViewportEngineRenderArea::ApplySchemeSettings( IScheme *pScheme )
{   
	BaseClass::ApplySchemeSettings( pScheme );
	m_OverlayTextFont = pScheme->GetFont( "DefaultLargeOutline" );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMiniViewportEngineRenderArea::ShutdownSceneMaterials()
{
	m_ScreenBuffer.Shutdown();
	m_ScreenMaterial.Shutdown();
}


//-----------------------------------------------------------------------------
// Sets text to draw over the window
//-----------------------------------------------------------------------------
void CMiniViewportEngineRenderArea::SetOverlayText( const char *pText )
{
	m_OverlayText = pText;
}

	
//-----------------------------------------------------------------------------
// Paints the black borders around the engine window
//-----------------------------------------------------------------------------
void CMiniViewportEngineRenderArea::PaintEngineBorders( int x, int y, int w, int h )
{
	// Draws black borders around the engine window
	surface()->DrawSetColor( Color( 0, 0, 0, 255 ) );
	if ( x != 0 )
	{
		surface()->DrawFilledRect( 0, 0, x, h );
		surface()->DrawFilledRect( x + w, 0, w + 2 * x, h );
	}
	else if ( y != 0 )
	{
		surface()->DrawFilledRect( 0, 0, w, y );
		surface()->DrawFilledRect( 0, y + h, w, h + 2 * y );
	}
}


//-----------------------------------------------------------------------------
// Paints the overlay text
//-----------------------------------------------------------------------------
void CMiniViewportEngineRenderArea::PaintOverlayText( )
{
	if ( !m_OverlayText.Length() )
		return;

	int cw, ch;
	GetSize( cw, ch );

	int nTextWidth, nTextHeight;
	int nBufLen = m_OverlayText.Length()+1;
	wchar_t *pTemp = (wchar_t*)_alloca( nBufLen * sizeof(wchar_t) );
	::MultiByteToWideChar( CP_UTF8, 0, m_OverlayText.Get(), -1, pTemp, nBufLen );

	g_pMatSystemSurface->GetTextSize( m_OverlayTextFont, pTemp, nTextWidth, nTextHeight );
	int lx = (cw - nTextWidth) / 2;
	if ( lx < 10 )
	{
		lx = 10;
	}
	int ly = ch - 10 - nTextHeight;
	g_pMatSystemSurface->DrawColoredTextRect( m_OverlayTextFont, 
		lx, ly, cw - lx, ch - ly,
		255, 255, 255, 255, "%s", m_OverlayText.Get() );
}


//-----------------------------------------------------------------------------
// Paints the engine window	itself
//-----------------------------------------------------------------------------
void CMiniViewportEngineRenderArea::PaintEngineWindow( int x, int y, int w, int h )
{
	if ( !enginetools->IsInGame() )
	{
		surface()->DrawSetColor( Color( 127, 127, 200, 63 ) );
		surface()->DrawFilledRect( x, y, x + w, y + h );
	}
	else
	{
		CMatRenderContextPtr pRenderContext( g_pMaterialSystem );

		g_pMatSystemSurface->DrawSetTextureMaterial( m_nEngineOutputTexture, m_ScreenMaterial );
		surface()->DrawSetColor( Color( 0, 0, 0, 255 ) );

		int nTexWidth = m_ScreenBuffer->GetActualWidth();
		int nTexHeight = m_ScreenBuffer->GetActualHeight();
		float flOOWidth = 1.0f / nTexWidth;
		float flOOHeight = 1.0f / nTexHeight;

		float s0, s1, t0, t1;

		s0 = ( 0.5f ) * flOOWidth;
		t0 = ( 0.5f ) * flOOHeight;
		s1 = ( (float)w - 0.5f ) * flOOWidth;
		t1 = ( (float)h - 0.5f ) * flOOHeight;

		vgui::surface()->DrawTexturedSubRect( x, y, x+w, y+h, s0, t0, s1, t1 );

		PaintOverlayText();
	}
}

//-----------------------------------------------------------------------------
// Paints the background
//-----------------------------------------------------------------------------
void CMiniViewportEngineRenderArea::PaintBackground()
{
	int x, y, w, h;
	GetEngineBounds( x, y, w, h );
	PaintEngineBorders( x, y, w, h );
	PaintEngineWindow( x, y, w, h );
}

void CMiniViewportEngineRenderArea::GetEngineBounds( int& x, int& y, int& w, int& h )
{
	x = 0;
	y = 0;
	GetSize( w, h );

	// Check aspect ratio
	int sx, sy;
	surface()->GetScreenSize( sx, sy );

	if ( sy > 0 && 
		h > 0 )
	{
		float screenaspect = (float)sx / (float)sy;
		float aspect = (float)w / (float)h;

		float ratio = screenaspect / aspect;

		// Screen is wider, need bars at top and bottom
		if ( ratio > 1.0f )
		{
			int usetall = (float)w / screenaspect;
			y = ( h - usetall ) / 2;
			h = usetall;
		}
		// Screen is narrower, need bars at left/right
		else
		{
			int usewide = (float)h * screenaspect;
			x = ( w - usewide ) / 2;
			w = usewide;
		}
	}
}

CMiniViewportPropertyPage::CMiniViewportPropertyPage(Panel *parent, const char *panelName ) :
	BaseClass( parent, panelName )
{
	m_bgColor = Color( 0, 0, 0, 0 );

	m_pViewportArea = new CMiniViewportEngineRenderArea( this, "Engine" );
}

void CMiniViewportPropertyPage::PerformLayout()
{
	BaseClass::PerformLayout();

	int w, h;
	GetSize( w, h );
	m_pViewportArea->SetBounds( 0, 0, w, h );
}

Color CMiniViewportPropertyPage::GetBgColor()
{
	return m_bgColor;
}


void CMiniViewportPropertyPage::GetEngineBounds( int& x, int& y, int& w, int& h )
{
	m_pViewportArea->GetEngineBounds( x, y, w, h );
	m_pViewportArea->LocalToScreen( x, y );
}

void CMiniViewportPropertyPage::RenderFrameBegin()
{
	m_pViewportArea->RenderFrameBegin();
}

CMiniViewport::CMiniViewport( vgui::Panel *parent, bool contextLabel, vgui::IToolWindowFactory *factory /*= 0*/, 
	vgui::Panel *page /*= NULL*/, char const *title /*= NULL*/, bool contextMenu /*= false*/ ) :
	BaseClass( parent, contextLabel, factory, page, title, contextMenu, false )
{
	SetCloseButtonVisible( false );

	GetPropertySheet()->SetDraggableTabs( false );

	// Add the viewport panel
	m_hPage = new CMiniViewportPropertyPage( this, "ViewportPage" );

	AddPage( m_hPage.Get(), "#ToolMiniViewport", false );
}

void CMiniViewport::GetViewport( bool& enabled, int& x, int& y, int& w, int& h )
{
	enabled = false;
	x = y = w = h = 0;

	int screenw, screenh;
	surface()->GetScreenSize( screenw, screenh );

	m_hPage->GetEngineBounds( x, y, w, h );

	y = screenh - ( y + h );
}

void CMiniViewport::GetEngineBounds( int& x, int& y, int& w, int& h )
{
	m_hPage->GetEngineBounds( x, y, w, h );
}


//-----------------------------------------------------------------------------
// Called when the layoff texture needs to be released
//-----------------------------------------------------------------------------
void CMiniViewport::ReleaseLayoffTexture()
{
	if ( m_hPage.Get() )
	{
		m_hPage->GetViewportArea()->ReleaseLayoffTexture();
	}
}


//-----------------------------------------------------------------------------
// Sets text to draw over the window
//-----------------------------------------------------------------------------
void CMiniViewport::SetOverlayText( const char *pText )
{
	if ( m_hPage.Get() )
	{
		m_hPage->GetViewportArea()->SetOverlayText( pText );
	}
}

void CMiniViewport::RenderFrameBegin()
{
	if ( m_hPage.Get() )
	{
		m_hPage->RenderFrameBegin();
	}
}