source-engine/utils/hlfaceposer/matsyswin.cpp

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

#include <mxtk/mx.h>
#include <mxtk/mxMessageBox.h>
#include <mxtk/mxTga.h>
#include <mxtk/mxPcx.h>
#include <mxtk/mxBmp.h>
#include <mxtk/mxMatSysWindow.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "MatSysWin.h"
#include "MDLViewer.h"
#include "StudioModel.h"
#include "ControlPanel.h"
#include "ViewerSettings.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/imaterialproxyfactory.h"
#include "filesystem.h"
#include <keyvalues.h>
#include "materialsystem/imesh.h"
#include "expressions.h"
#include "hlfaceposer.h"
#include "ifaceposersound.h"
#include "materialsystem/IMaterialSystemHardwareConfig.h"
#include "materialsystem/itexture.h"
#include "materialsystem/MaterialSystem_Config.h"
#include "istudiorender.h"
#include "choreowidgetdrawhelper.h"
#include "faceposer_models.h"
#include "tier0/icommandline.h"
#include "mathlib/vmatrix.h"
#include "vstdlib/cvar.h"

IFileSystem *filesystem = NULL;

extern char g_appTitle[];

// FIXME: move all this to mxMatSysWin

class DummyMaterialProxyFactory : public IMaterialProxyFactory
{
public:
	virtual IMaterialProxy *CreateProxy( const char *proxyName )	{return NULL;}
	virtual void DeleteProxy( IMaterialProxy *pProxy )				{}
};
DummyMaterialProxyFactory	g_DummyMaterialProxyFactory;


static void ReleaseMaterialSystemObjects()
{
	StudioModel::ReleaseStudioModel();
	models->ReleaseModels();
}

static void RestoreMaterialSystemObjects( int nChangeFlags )
{
	StudioModel::RestoreStudioModel();
	models->RestoreModels();
}

void InitMaterialSystemConfig(MaterialSystem_Config_t *pConfig)
{
	pConfig->SetFlag( MATSYS_VIDCFG_FLAGS_USING_MULTIPLE_WINDOWS, true );
}

Vector g_vright( 50, 50, 0 );		// needs to be set to viewer's right in order for chrome to work

IMaterial *g_materialBackground = NULL;
IMaterial *g_materialWireframe = NULL;
IMaterial *g_materialWireframeVertexColor = NULL;
IMaterial *g_materialWireframeVertexColorNoCull = NULL;
IMaterial *g_materialDebugCopyBaseTexture = NULL;
IMaterial *g_materialFlatshaded = NULL;
IMaterial *g_materialSmoothshaded = NULL;
IMaterial *g_materialBones = NULL;
IMaterial *g_materialLines = NULL;
IMaterial *g_materialFloor = NULL;
IMaterial *g_materialVertexColor = NULL;
IMaterial *g_materialShadow = NULL;

MatSysWindow		*g_pMatSysWindow = 0;

#define MATSYSWIN_NAME "3D View"

MatSysWindow::MatSysWindow (mxWindow *parent, int x, int y, int w, int h, const char *label, int style)
: IFacePoserToolWindow( "3D View", "3D View" ), mxMatSysWindow ( parent, x, y, w, h, label, style )
{
	g_pMaterialSystem->SetMaterialProxyFactory( &g_DummyMaterialProxyFactory );

	SetAutoProcess( true );

	setLabel( MATSYSWIN_NAME );

	m_bSuppressSwap = false;

	m_hWnd = (HWND)getHandle();

	Con_Printf( "Setting material system video mode\n" );

	MaterialSystem_Config_t config;
	config = g_pMaterialSystem->GetCurrentConfigForVideoCard();
	InitMaterialSystemConfig(&config);
	g_pMaterialSystem->OverrideConfig( config, false );
	
//	config.m_VideoMode.m_Width = config.m_VideoMode.m_Height = 0;
	config.SetFlag( MATSYS_VIDCFG_FLAGS_WINDOWED, true );
	config.SetFlag( MATSYS_VIDCFG_FLAGS_RESIZING, true );

	if (!g_pMaterialSystem->SetMode( ( void * )m_hWnd, config ) )
	{
		return;
	}
	g_pMaterialSystem->AddReleaseFunc( ReleaseMaterialSystemObjects );
	g_pMaterialSystem->AddRestoreFunc( RestoreMaterialSystemObjects );

	Con_Printf( "Loading debug materials\n" );

	ITexture *pCubemapTexture = g_pMaterialSystem->FindTexture( "hlmv/cubemap", NULL, true );
	pCubemapTexture->IncrementReferenceCount();
	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
	pRenderContext->BindLocalCubemap( pCubemapTexture );

	g_materialBackground	= g_pMaterialSystem->FindMaterial("particle/particleapp_background", TEXTURE_GROUP_OTHER, true);
	g_materialWireframe		= g_pMaterialSystem->FindMaterial("debug/debugmrmwireframe", TEXTURE_GROUP_OTHER, true);
	g_materialWireframeVertexColor = g_pMaterialSystem->FindMaterial("debug/debugwireframevertexcolor", TEXTURE_GROUP_OTHER, true);

	// test: create this from code - you need a vmt to make $nocull 1 happen, can't do it from the render context
	{
		KeyValues *pVMTKeyValues = new KeyValues( "Wireframe" );
		pVMTKeyValues->SetInt("$ignorez", 1);
		pVMTKeyValues->SetInt("$nocull", 1);
		pVMTKeyValues->SetInt("$vertexcolor", 1);
		pVMTKeyValues->SetInt("$decal", 1);
		g_materialWireframeVertexColorNoCull = g_pMaterialSystem->CreateMaterial( "debug/wireframenocull", pVMTKeyValues );
	}
	{
		KeyValues *pVMTKeyValues = new KeyValues( "UnlitGeneric" );
		pVMTKeyValues->SetString("$basetexture", "vgui/white" );
		g_materialDebugCopyBaseTexture = g_pMaterialSystem->CreateMaterial( "debug/copybasetexture", pVMTKeyValues );

	}

	g_materialFlatshaded	= g_pMaterialSystem->FindMaterial("debug/debugdrawflatpolygons", TEXTURE_GROUP_OTHER, true);
	g_materialSmoothshaded	= g_pMaterialSystem->FindMaterial("debug/debugmrmfullbright2", TEXTURE_GROUP_OTHER, true);
	g_materialBones			= g_pMaterialSystem->FindMaterial("debug/debugmrmwireframe", TEXTURE_GROUP_OTHER, true);
	g_materialLines			= g_pMaterialSystem->FindMaterial("debug/debugwireframevertexcolor", TEXTURE_GROUP_OTHER, true);
	g_materialFloor			= g_pMaterialSystem->FindMaterial("hlmv/floor", TEXTURE_GROUP_OTHER, true);
	g_materialVertexColor   = g_pMaterialSystem->FindMaterial("debug/debugvertexcolor", TEXTURE_GROUP_OTHER, true);
	g_materialShadow		= g_pMaterialSystem->FindMaterial("hlmv/shadow", TEXTURE_GROUP_OTHER, true);

	if (!parent)
		setVisible (true);
	else
		mx::setIdleWindow (this);

	m_bSuppressResize = false;

	m_stickyDepth = 0;
	m_bIsSticky = false;
	m_snapshotDepth = 0;
}



MatSysWindow::~MatSysWindow ()
{
	mx::setIdleWindow (0);
}

void MatSysWindow::redraw()
{
	BaseClass::redraw();
return;
	if ( IsLocked() )
	{
		RECT bounds;
		GetClientRect( (HWND)getHandle(), &bounds );
		bounds.bottom = bounds.top + GetCaptionHeight();
		CChoreoWidgetDrawHelper helper( this, bounds );
		HandleToolRedraw( helper );
	}
}

#define MAX_FPS 250.0f
#define MIN_TIMESTEP ( 1.0f / MAX_FPS )

double realtime = 0.0f;

void MatSysWindow::Frame( void )
{
	static bool recursion_guard = false;

	static double prev = 0.0;
	double curr = (double) mx::getTickCount () / 1000.0;
	double dt = ( curr - prev );
	
	if ( recursion_guard )
		return;

	recursion_guard = true;

	// clamp to MAX_FPS
	if ( dt >= 0.0 && dt < MIN_TIMESTEP )
	{
		Sleep( max( 0, (int)( ( MIN_TIMESTEP - dt ) * 1000.0f ) ) );

		recursion_guard = false;
		return;
	}

	if ( prev != 0.0 )
	{
		dt = min( 0.1, dt );
		
		g_MDLViewer->Think( dt );

		realtime += dt;
	}
	
	prev = curr;

	DrawFrame();

	recursion_guard = false;
}

void MatSysWindow::DrawFrame( void )
{
	if (!g_viewerSettings.pause)
	{
		redraw ();
	}
}

int MatSysWindow::handleEvent (mxEvent *event)
{
	MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );

	int iret = 0;
	
	if ( HandleToolEvent( event ) )
	{
		return iret;
	}

	static float oldrx = 0, oldry = 0, oldtz = 50, oldtx = 0, oldty = 0;
	static float oldlrx = 0, oldlry = 0;
	static int oldx, oldy;

	switch (event->event)
	{
	case mxEvent::Idle:
		{
			iret = 1;

			Frame();
		}
		break;

	case mxEvent::MouseDown:
		{
			StudioModel *pModel = models->GetActiveStudioModel();
			if (!pModel)
				break;
			oldrx = pModel->m_angles[0];
			oldry = pModel->m_angles[1];
			oldtx = pModel->m_origin[0];
			oldty = pModel->m_origin[1];
			oldtz = pModel->m_origin[2];
			oldx = (short)event->x;
			oldy = (short)event->y;
			oldlrx = g_viewerSettings.lightrot[0];
			oldlry = g_viewerSettings.lightrot[1];
			g_viewerSettings.pause = false;

			float r = 1.0/3.0 * min( w(), h() );

			float d = sqrt( ( float )( (event->x - w()/2) * (event->x - w()/2) + (event->y - h()/2) * (event->y - h()/2) ) );

			if (d < r)
				g_viewerSettings.rotating = false;
			else
				g_viewerSettings.rotating = true;

			iret = 1;
		}
		break;

	case mxEvent::MouseDrag:
		{
			StudioModel *pModel = models->GetActiveStudioModel();
			if (!pModel)
				break;

			if (event->buttons & mxEvent::MouseLeftButton)
			{
				if (event->modifiers & mxEvent::KeyShift)
				{
					pModel->m_origin[1] = oldty - (float) ((short)event->x - oldx) * 0.1;
					pModel->m_origin[2] = oldtz + (float) ((short)event->y - oldy) * 0.1;
				}
				else if (event->modifiers & mxEvent::KeyCtrl)
				{
					float ry = (float) (event->y - oldy);
					float rx = (float) (event->x - oldx);
					oldx = event->x;
					oldy = event->y;
					
					QAngle movement = QAngle( ry, rx, 0 );
					
					matrix3x4_t tmp1, tmp2, tmp3;
					AngleMatrix( g_viewerSettings.lightrot, tmp1 );
					AngleMatrix( movement, tmp2 );
					ConcatTransforms( tmp2, tmp1, tmp3 );
					MatrixAngles( tmp3, g_viewerSettings.lightrot );
				}
				else
				{
					if (!g_viewerSettings.rotating)
					{
						float ry = (float) (event->y - oldy);
						float rx = (float) (event->x - oldx);
						oldx = event->x;
						oldy = event->y;
						
						QAngle movement;
						matrix3x4_t tmp1, tmp2, tmp3;
						
						movement = QAngle( 0, rx, 0 );
						AngleMatrix( pModel->m_angles, tmp1 );
						AngleMatrix( movement, tmp2 );
						ConcatTransforms( tmp1, tmp2, tmp3 );
						MatrixAngles( tmp3, pModel->m_angles );
						
						movement = QAngle( ry, 0, 0 );
						AngleMatrix( pModel->m_angles, tmp1 );
						AngleMatrix( movement, tmp2 );
						ConcatTransforms( tmp2, tmp1, tmp3 );
						MatrixAngles( tmp3, pModel->m_angles );
					}
					else
					{
						float ang1 = (180 / 3.1415) * atan2( oldx - w()/2.0, oldy - h()/2.0 );
						float ang2 = (180 / 3.1415) * atan2( event->x - w()/2.0, event->y - h()/2.0 );
						oldx = event->x;
						oldy = event->y;
						
						QAngle movement = QAngle( 0, 0, ang2 - ang1 );
						
						matrix3x4_t tmp1, tmp2, tmp3;
						AngleMatrix( pModel->m_angles, tmp1 );
						AngleMatrix( movement, tmp2 );
						ConcatTransforms( tmp2, tmp1, tmp3 );
						MatrixAngles( tmp3, pModel->m_angles );
					}			
				}
			}
			else if (event->buttons & mxEvent::MouseRightButton)
			{
				pModel->m_origin[0] = oldtx + (float) ((short)event->y - oldy) * 0.1;
				pModel->m_origin[0] = clamp( pModel->m_origin[0], 8.0f, 1024.0f );
			}
			redraw ();

			iret = 1;
		}
		break;

	case mxEvent::KeyDown:
		{
			iret = 1;
			switch (event->key)
			{
			default:
				iret = 0;
				break;
			case 116: // F5
				{
					g_MDLViewer->Refresh();
				}
				break;
			case 32:
				{
					int iSeq = models->GetActiveStudioModel()->GetSequence();
					if (iSeq == models->GetActiveStudioModel()->SetSequence (iSeq + 1))
					{
						g_pControlPanel->setSequence( 0 );
					}
					else
					{
						g_pControlPanel->setSequence( iSeq + 1 );
					}
				}
				break;
				
			case 27:
				if (!getParent ()) // fullscreen mode ?
					mx::quit ();
				break;
				
			case 'g':
				g_viewerSettings.showGround = !g_viewerSettings.showGround;
				break;
				
			case 'h':
				g_viewerSettings.showHitBoxes = !g_viewerSettings.showHitBoxes;
				break;
				
			case 'o':
				g_viewerSettings.showBones = !g_viewerSettings.showBones;
				break;
				
			case 'b':
				g_viewerSettings.showBackground = !g_viewerSettings.showBackground;
				break;
				
			case 'm':
				g_viewerSettings.showMovement = !g_viewerSettings.showMovement;
				break;
				
			case '1':
			case '2':
			case '3':
			case '4':
				g_viewerSettings.renderMode = event->key - '1';
				break;
				
			case '-':
				g_viewerSettings.speedScale -= 0.1f;
				if (g_viewerSettings.speedScale < 0.0f)
					g_viewerSettings.speedScale = 0.0f;
				break;
				
			case '+':
				g_viewerSettings.speedScale += 0.1f;
				if (g_viewerSettings.speedScale > 5.0f)
					g_viewerSettings.speedScale = 5.0f;
				break;
			}
		}
		break;
	} // switch (event->event)

	return iret;
}



void
drawFloor ()
{
	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
	pRenderContext->Bind(g_materialFloor);
	pRenderContext->MatrixMode(MATERIAL_MODEL);
	pRenderContext->PushMatrix();
	pRenderContext->LoadIdentity();
	pRenderContext->MatrixMode(MATERIAL_VIEW);
	pRenderContext->PushMatrix();
	pRenderContext->LoadIdentity();
	{
		IMesh* pMesh = pRenderContext->GetDynamicMesh();
		CMeshBuilder meshBuilder;
		meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );

		float dist=-15000.0f;
		float tMin=0, tMax=1;
		
		meshBuilder.Position3f(-dist, dist, dist);
		meshBuilder.TexCoord2f( 0, tMin,tMax );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f( dist, dist, dist);
		meshBuilder.TexCoord2f( 0, tMax,tMax );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f( dist,-dist, dist);
		meshBuilder.TexCoord2f( 0, tMax,tMin );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.Position3f(-dist,-dist, dist);
		meshBuilder.TexCoord2f( 0, tMin,tMin );
		meshBuilder.Color4ub( 255, 255, 255, 255 );
		meshBuilder.AdvanceVertex();

		meshBuilder.End();
		pMesh->Draw();
	}
	pRenderContext->MatrixMode(MATERIAL_MODEL);
	pRenderContext->PopMatrix();
	pRenderContext->MatrixMode(MATERIAL_VIEW);
	pRenderContext->PopMatrix();
}



void
setupRenderMode ()
{
}

void MatSysWindow::SuppressBufferSwap( bool bSuppress )
{
	m_bSuppressSwap = bSuppress;
}

void MatSysWindow::draw ()
{
	int i;

	g_pMaterialSystem->BeginFrame( 0 );
	CUtlVector< StudioModel * > modellist;

	modellist.AddToTail( models->GetActiveStudioModel() );

	if ( models->CountVisibleModels() > 0 )
	{
		modellist.RemoveAll();
		for ( i = 0; i < models->Count(); i++ )
		{
			if ( models->IsModelShownIn3DView( i ) )
			{
				modellist.AddToTail( models->GetStudioModel( i ) );
			}
		}
	}

	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
	pRenderContext->ClearBuffers(true, true);

	int captiony = GetCaptionHeight();
	int viewh = h2() - captiony;

	g_pMaterialSystem->SetView( (HWND)getHandle() );

	pRenderContext->Viewport( 0, captiony, w2(), viewh );

	pRenderContext->MatrixMode( MATERIAL_PROJECTION );
	pRenderContext->LoadIdentity( );
	pRenderContext->PerspectiveX(20.0f, (float)w2() / (float)viewh, 1.0f, 20000.0f);
	
	pRenderContext->MatrixMode( MATERIAL_VIEW );
	pRenderContext->LoadIdentity( );
	// FIXME: why is this needed?  Doesn't SetView() override this?
	pRenderContext->Rotate( -90,  1, 0, 0 );	    // put Z going up
	pRenderContext->Rotate( -90,  0, 0, 1 );

	int modelcount = modellist.Count();
	int countover2 = modelcount / 2;
	int ydelta = g_pControlPanel->GetModelGap();
	int yoffset = -countover2 * ydelta;
	for ( i = 0 ; i < modelcount; i++ )
	{
		modellist[ i ]->IncrementFramecounter( );

		Vector oldtrans = modellist[ i ]->m_origin;

		modellist[ i ]->m_origin[ 1 ] = oldtrans[ 1 ] + yoffset;
		yoffset += ydelta;

		modellist[ i ]->GetStudioRender()->BeginFrame();
		modellist[ i ]->DrawModel();
		modellist[ i ]->GetStudioRender()->EndFrame();

		modellist[ i ]->m_origin = oldtrans;
	}

	//
	// draw ground
	//
	if (g_viewerSettings.showGround)
	{
		drawFloor ();
	}

	if (!m_bSuppressSwap)
	{
		g_pMaterialSystem->SwapBuffers();
	}

	g_pMaterialSystem->EndFrame();
}

void MatSysWindow::EnableStickySnapshotMode( )
{
	m_stickyDepth++;
}

void MatSysWindow::DisableStickySnapshotMode( )
{
	if (--m_stickyDepth == 0)
	{
		if (m_bIsSticky)
		{
			m_bIsSticky = false;

			HWND wnd = (HWND)getHandle();

			// Move back to original position
			SetWindowPlacement( wnd, &m_wp );

			SuppressResize( false );

			SetCursor( m_hPrevCursor );
		}
	}
}


void MatSysWindow::PushSnapshotMode( int nSnapShotSize )
{
	if (m_snapshotDepth++ == 0)
	{
		if (m_stickyDepth)
		{
			if (m_bIsSticky)
				return;

			m_bIsSticky = true;
			m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_WAIT ) );
		}

		SuppressResize( true );

		RECT rcClient;
		HWND wnd = (HWND)getHandle();

		GetWindowPlacement( wnd, &m_wp );

		GetClientRect( wnd, &rcClient );

		MoveWindow( wnd, 0, 0, nSnapShotSize + 16, nSnapShotSize + 16, TRUE );
	}
}


void MatSysWindow::PopSnapshotMode( )
{
	if (--m_snapshotDepth == 0)
	{
		if (m_stickyDepth == 0)
		{
			HWND wnd = (HWND)getHandle();

			// Move back to original position
			SetWindowPlacement( wnd, &m_wp );

			SuppressResize( false );
		}
	}
}


void MatSysWindow::TakeSnapshotRect( const char *pFilename, int x, int y, int w, int h )
{
	int i;
	HANDLE hf;
	BITMAPFILEHEADER hdr;
	BITMAPINFOHEADER bi;
	DWORD dwTmp, imageSize;
	byte *hp, b, *pBlue, *pRed;

	w = ( w + 3 ) & ~3;

	imageSize = w * h * 3;
	// Create the file
	hf = CreateFile( pFilename, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
	if( hf == INVALID_HANDLE_VALUE )
	{
		return;
	}

	// file header
	hdr.bfType = 0x4d42;	// 'BM'
	hdr.bfSize = (DWORD) ( sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + imageSize );
	hdr.bfReserved1 = 0;
	hdr.bfReserved2 = 0;
	hdr.bfOffBits = (DWORD) ( sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) );

	if( !WriteFile( hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER), (LPDWORD) &dwTmp, NULL ) )
		Error( "Couldn't write file header to snapshot.\n" );

	// bitmap header
	bi.biSize = sizeof(BITMAPINFOHEADER);
	bi.biWidth = w;
	bi.biHeight = h;
	bi.biPlanes = 1;
	bi.biBitCount = 24;
	bi.biCompression = BI_RGB;
	bi.biSizeImage = 0;	//vid.rowbytes * vid.height;
	bi.biXPelsPerMeter = 0;
	bi.biYPelsPerMeter = 0;
	bi.biClrUsed = 0;
	bi.biClrImportant = 0;

	if( !WriteFile( hf, (LPVOID) &bi, sizeof(BITMAPINFOHEADER), (LPDWORD) &dwTmp, NULL ) )
		Error( "Couldn't write bitmap header to snapshot.\n" );

	// bitmap bits
	hp = (byte *) malloc(imageSize);
	
	if (hp == NULL)
		Error( "Couldn't allocate bitmap header to snapshot.\n" );

	// Get Bits from the renderer
	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
	pRenderContext->ReadPixels( x, y, w, h, hp, IMAGE_FORMAT_RGB888 );

	// Invert vertically for BMP format
	for (i = 0; i < h / 2; i++)
	{
		byte *top = hp + i * w * 3;
		byte *bottom = hp + (h - i - 1) * w * 3;
		for (int j = 0; j < w * 3; j++)
		{
			b = *top;
			*top = *bottom;
			*bottom = b;
			top++;
			bottom++;
		}
	}

	// Reverse Red and Blue
	pRed = hp;
	pBlue = pRed + 2;
	for(i = 0; i < w * h;i++)
	{
		b = *pRed;
		*pRed = *pBlue;
		*pBlue = b;
		pBlue += 3;
		pRed += 3;
	}

	if( !WriteFile( hf, (LPVOID)hp, imageSize, (LPDWORD) &dwTmp, NULL ) )
		Error( "Couldn't write bitmap data snapshot.\n" );

	free(hp);

	// clean up
	if( !CloseHandle( hf ) )
		Error( "Couldn't close file for snapshot.\n" );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool MatSysWindow::IsSuppressingResize( void )
{
	return m_bSuppressResize;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : suppress - 
//-----------------------------------------------------------------------------
void MatSysWindow::SuppressResize( bool suppress )
{
	m_bSuppressResize = suppress;
}

void
MatSysWindow::TakeScreenShot (const char *filename)
{
	redraw ();
	int w = w2 ();
	int h = h2 ();

	mxImage *image = new mxImage ();
	if (image->create (w, h, 24))
	{
#if 0
		glReadBuffer (GL_FRONT);
		glReadPixels (0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE, image->data);
#else
		HDC hdc = GetDC ((HWND) getHandle ());
		byte *data = (byte *) image->data;
		int i = 0;
		for (int y = 0; y < h; y++)
		{
			for (int x = 0; x < w; x++)
			{
				COLORREF cref = GetPixel (hdc, x, y);
				data[i++] = (byte) ((cref >> 0)& 0xff);
				data[i++] = (byte) ((cref >> 8) & 0xff);
				data[i++] = (byte) ((cref >> 16) & 0xff);
			}
		}
		ReleaseDC ((HWND) getHandle (), hdc);
#endif
		if (!mxTgaWrite (filename, image))
			mxMessageBox (this, "Error writing screenshot.", g_appTitle, MX_MB_OK | MX_MB_ERROR);

		delete image;
	}
}