d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
551 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
source-engine/utils/xbox/Test360/TriangleASM.cpp

981 lines
23 KiB
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//--------------------------------------------------------------------------------------
// TriangleASM.cpp
//
// Hijacked from samples, assimilated into valve app.
//--------------------------------------------------------------------------------------
#include "tier0\platform.h"
#if !defined( _X360 )
#include <windows.h>
#endif
#include "appframework\iappsystemgroup.h"
#include "appframework\appframework.h"
#include "tier0\dbg.h"
#include "tier1\interface.h"
#include "filesystem.h"
#include "vstdlib\cvar.h"
#include "filesystem_init.h"
#include "tier1/utlbuffer.h"
#include "icommandline.h"
#include "datacache\idatacache.h"
#include "datacache\imdlcache.h"
#include "studio.h"
#include "utlbuffer.h"
#include "tier2\utlstreambuffer.h"
#include "tier2\tier2.h"
#include "tier3\tier3.h"
#include "mathlib/mathlib.h"
#include "inputsystem\iinputsystem.h"
#include "vphysics_interface.h"
#include "istudiorender.h"
#include "studio.h"
#include "tier1\KeyValues.h"
#include "vgui\IVGui.h"
#include "vguimatsurface\imatsystemsurface.h"
#include "matsys_controls\matsyscontrols.h"
#include "vgui\ILocalize.h"
#include "vgui_controls\panel.h"
#include "vgui_controls\label.h"
#if defined( _X360 )
#include "xbox\xbox_console.h"
#include "xbox\xbox_win32stubs.h"
#endif
#include "materialsystem\imaterialsystem.h"
#include "materialsystem\imesh.h"
#include "materialsystem\materialsystem_config.h"
#include "materialsystem\MaterialSystemUtil.h"
#include "materialsystem\ishaderapi.h"
#if !defined( _X360 )
#include "xbox\xboxstubs.h"
#endif
#include "bone_setup.h"
#include "tier0\memdbgon.h"
bool g_bActive = true;
extern SpewOutputFunc_t g_DefaultSpewFunc;
// These must be turned on in order....
#define USE_FILESYSTEM
#define USE_MATERIALSYSTEM
#define USE_VPHYSICS
// Note: VPHYSICS is just used via the datacache to load a model's physics collision mesh
// These can be turned on in any order
#define USE_INPUTSYSTEM
#define USE_VGUI
#define USE_STUDIORENDER
#pragma warning(disable:4189) // local variable is initialized but not referenced
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
class CTest360App : public CDefaultAppSystemGroup<CSteamAppSystemGroup>
{
public:
virtual bool Create();
virtual bool PreInit();
virtual int Main();
virtual void Destroy();
private:
const char *GetAppName() { return "TEST360"; }
void RenderScene();
bool CreateMainWindow( int width, int height, bool fullscreen );
#if defined( USE_MATERIALSYSTEM )
bool SetupMaterialSystem();
#endif
#if defined( USE_STUDIORENDER )
bool SetupStudioRender();
bool LoadModel( const char *pModelName );
matrix3x4_t* SetUpBones( studiohdr_t *pStudioHdr, const matrix3x4_t &modelMatrix );
#endif
#if defined( USE_VGUI )
int InitializeVGUI( void );
void ShutdownVGUI( void );
#endif
IPhysicsCollision *m_pCollision;
IMaterialSystem *m_pMaterialSystem;
IFileSystem *m_pFileSystem;
int m_nWidth;
int m_nHeight;
float m_fAspect;
float m_NearClip;
float m_FarClip;
float m_fov;
HWND m_hWnd;
studiohdr_t *m_pStudioHdr;
studiohwdata_t *m_pStudioHWData;
int m_nLod;
float m_flTime;
float m_flPlaybackRate;
vgui::Panel *m_pMainPanel;
};
static float g_yaw;
static float g_horizontalPan;
static float g_verticalPan;
static float g_zoom;
static int g_sequence;
static bool g_bWireframe;
DEFINE_WINDOWED_STEAM_APPLICATION_OBJECT( CTest360App );
#if defined( USE_MATERIALSYSTEM )
static void MaterialSystem_Warning( const char *fmt, ... )
{
va_list argptr;
char msg[2048];
va_start( argptr, fmt );
Q_vsnprintf( msg, sizeof ( msg ), fmt, argptr );
va_end( argptr );
OutputDebugString( msg );
}
#endif
#if defined( USE_MATERIALSYSTEM )
static void MaterialSystem_Warning( char *fmt, ... )
{
va_list argptr;
char msg[2048];
va_start( argptr, fmt );
Q_vsnprintf( msg, sizeof( msg ), fmt, argptr );
va_end( argptr );
OutputDebugString( msg );
}
#endif
virtualmodel_t *studiohdr_t::GetVirtualModel( void ) const
{
if ( numincludemodels == 0 )
return NULL;
return g_pMDLCache->GetVirtualModelFast( this, (MDLHandle_t)virtualModel );
}
byte *studiohdr_t::GetAnimBlock( int i ) const
{
return g_pMDLCache->GetAnimBlock( (MDLHandle_t)virtualModel, i );
}
int studiohdr_t::GetAutoplayList( unsigned short **pOut ) const
{
return g_pMDLCache->GetAutoplayList( (MDLHandle_t)virtualModel, pOut );
}
const studiohdr_t *virtualgroup_t::GetStudioHdr( void ) const
{
return g_pMDLCache->GetStudioHdr( (MDLHandle_t)cache );
}
#if defined( USE_STUDIORENDER )
matrix3x4_t* CTest360App::SetUpBones( studiohdr_t *pStudioHdr, const matrix3x4_t &shapeToWorld )
{
// Default to middle of the pose parameter range
float pPoseParameter[MAXSTUDIOPOSEPARAM];
for ( int i = 0; i < MAXSTUDIOPOSEPARAM; ++i )
{
pPoseParameter[i] = 0.5f;
}
CStudioHdr studioHdr( pStudioHdr, g_pMDLCache );
int nFrameCount = Studio_MaxFrame( &studioHdr, g_sequence, pPoseParameter );
if ( nFrameCount == 0 )
{
nFrameCount = 1;
}
float flCycle = ( m_flTime * m_flPlaybackRate ) / nFrameCount;
// FIXME: We're always wrapping; may want to determing if we should clamp
flCycle -= (int)(flCycle);
int boneMask = BONE_USED_BY_VERTEX_AT_LOD( m_nLod );
Vector pos[MAXSTUDIOBONES];
Quaternion q[MAXSTUDIOBONES];
IBoneSetup boneSetup( &studioHdr, boneMask, pPoseParameter );
boneSetup.InitPose( pos, q );
boneSetup.AccumulatePose( pos, q, g_sequence, flCycle, 1.0f, m_flTime, NULL );
// FIXME: Try enabling this?
// CalcAutoplaySequences( pStudioHdr, NULL, pos, q, pPoseParameter, BoneMask( ), flTime );
// Root transform
matrix3x4_t rootToWorld, temp;
MatrixCopy( shapeToWorld, rootToWorld );
matrix3x4_t *pBoneToWorld = g_pStudioRender->LockBoneMatrices( studioHdr.numbones() );
for ( int i = 0; i < studioHdr.numbones(); i++ )
{
// If it's not being used, fill with NAN for errors
if ( !(studioHdr.pBone( i )->flags & boneMask) )
{
int j, k;
for (j = 0; j < 3; j++)
{
for (k = 0; k < 4; k++)
{
pBoneToWorld[i][j][k] = VEC_T_NAN;
}
}
continue;
}
matrix3x4_t boneMatrix;
QuaternionMatrix( q[i], boneMatrix );
MatrixSetColumn( pos[i], 3, boneMatrix );
if (studioHdr.pBone(i)->parent == -1)
{
ConcatTransforms (rootToWorld, boneMatrix, pBoneToWorld[i]);
}
else
{
ConcatTransforms (pBoneToWorld[ studioHdr.pBone(i)->parent ], boneMatrix, pBoneToWorld[i] );
}
}
return pBoneToWorld;
}
#endif
//--------------------------------------------------------------------------------------
// LoadModel
//
//--------------------------------------------------------------------------------------
#if defined( USE_STUDIORENDER )
bool CTest360App::LoadModel( const char* pModelName )
{
MDLHandle_t hMdl = g_pMDLCache->FindMDL( pModelName );
m_pStudioHdr = g_pMDLCache->GetStudioHdr( hMdl );
g_pMDLCache->GetVertexData( hMdl );
g_pMDLCache->FinishPendingLoads();
g_pMDLCache->GetHardwareData( hMdl );
g_pMDLCache->FinishPendingLoads();
m_pStudioHWData = g_pMDLCache->GetHardwareData( hMdl );
g_sequence = 0;
m_nLod = 0;
m_flPlaybackRate = 30.0;
g_yaw = 0;
g_zoom = -100;
g_horizontalPan = 0;
g_verticalPan = -30;
return true;
}
#endif
//--------------------------------------------------------------------------------------
// SetupMaterialSystem
//
//--------------------------------------------------------------------------------------
#if defined( USE_MATERIALSYSTEM )
bool CTest360App::SetupMaterialSystem()
{
RECT rect;
MaterialSystem_Config_t config;
config.SetFlag( MATSYS_VIDCFG_FLAGS_WINDOWED, IsPC() ? true : false );
config.SetFlag( MATSYS_VIDCFG_FLAGS_NO_WAIT_FOR_VSYNC, 0 );
config.m_VideoMode.m_Width = 0;
config.m_VideoMode.m_Height = 0;
config.m_VideoMode.m_Format = IMAGE_FORMAT_BGRX8888;
config.m_VideoMode.m_RefreshRate = 0;
config.dxSupportLevel = IsX360() ? 98 : 0;
bool modeSet = m_pMaterialSystem->SetMode( m_hWnd, config );
if ( !modeSet )
{
Error( "Failed to set mode\n" );
return false;
}
m_pMaterialSystem->OverrideConfig( config, false );
GetClientRect( m_hWnd, &rect );
m_nWidth = rect.right;
m_nHeight = rect.bottom;
m_fAspect = (float)m_nWidth/(float)m_nHeight;
m_NearClip = 8.0f;
m_FarClip = 28400.0f;
m_fov = 90;
return true;
}
#endif
//--------------------------------------------------------------------------------------
// SetupStudioRender
//
//--------------------------------------------------------------------------------------
#if defined( USE_STUDIORENDER )
bool CTest360App::SetupStudioRender()
{
StudioRenderConfig_t config;
memset( &config, 0, sizeof(config) );
config.bEyeMove = false;
config.bTeeth = true;
config.bEyes = true;
config.bFlex = true;
config.fEyeShiftX = 0.0f;
config.fEyeShiftY = 0.0f;
config.fEyeShiftZ = 0.0f;
config.fEyeSize = 0.0f;
config.bNoHardware = false;
config.bNoSoftware = false;
config.bSoftwareSkin = false;
config.bSoftwareLighting = false;
config.drawEntities = true;
config.bWireframe = false;
config.SetNormals( false );
config.SetTangentFrame( false );
config.skin = 0;
config.fullbright = 0;
config.pConDPrintf = MaterialSystem_Warning;
config.pConPrintf = MaterialSystem_Warning;
config.bShowEnvCubemapOnly = false;
g_pStudioRender->UpdateConfig( config );
return true;
}
#endif
//--------------------------------------------------------------------------------------
// Render a model using the MaterialSystem
//--------------------------------------------------------------------------------------
void CTest360App::RenderScene()
{
m_flTime = Plat_FloatTime();
#if defined( USE_MATERIALSYSTEM )
CMatRenderContextPtr pRenderContext( m_pMaterialSystem );
m_pMaterialSystem->BeginFrame();
#endif
#if defined( USE_STUDIORENDER )
g_pStudioRender->BeginFrame();
#endif
#if defined( USE_MATERIALSYSTEM )
pRenderContext->ClearColor3ub( 0, 0, 0 );
pRenderContext->ClearBuffers( true, true );
#endif
#if defined( USE_STUDIORENDER )
pRenderContext->Viewport( 0, 0, m_nWidth, m_nHeight );
pRenderContext->MatrixMode( MATERIAL_PROJECTION );
pRenderContext->LoadIdentity();
pRenderContext->PerspectiveX( m_fov, m_fAspect, m_NearClip, m_FarClip );
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->LoadIdentity();
pRenderContext->Translate( g_horizontalPan, g_verticalPan, g_zoom );
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->LoadIdentity();
g_pStudioRender->SetLocalLights( 0, NULL );
pRenderContext->SetAmbientLight( 1.0, 1.0, 1.0 );
QAngle angles;
angles[YAW] = 0;
angles[PITCH] = -90 + g_yaw;
angles[ROLL] = -90;
matrix3x4_t cameraMatrix;
AngleMatrix( angles, cameraMatrix );
static Vector white[6] =
{
Vector( 1.0, 1.0, 1.0 ),
Vector( 1.0, 1.0, 1.0 ),
Vector( 1.0, 1.0, 1.0 ),
Vector( 1.0, 1.0, 1.0 ),
Vector( 1.0, 1.0, 1.0 ),
Vector( 1.0, 1.0, 1.0 ),
};
g_pStudioRender->SetAmbientLightColors( white );
matrix3x4_t *pBoneToWorld = SetUpBones( m_pStudioHdr, cameraMatrix );
Vector modelOrigin( 0, 0, 0 );
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->PushMatrix();
DrawModelInfo_t modelInfo;
memset( &modelInfo, 0, sizeof( modelInfo ) );
modelInfo.m_pStudioHdr = m_pStudioHdr;
modelInfo.m_pHardwareData = m_pStudioHWData;
modelInfo.m_Decals = STUDIORENDER_DECAL_INVALID;
modelInfo.m_Skin = 0;
modelInfo.m_Body = 0;
modelInfo.m_HitboxSet = 0;
modelInfo.m_pClientEntity = NULL;
modelInfo.m_Lod = 0;
modelInfo.m_ppColorMeshes = NULL;
int drawFlags = 0;
if ( g_bWireframe )
{
drawFlags |= STUDIORENDER_DRAW_WIREFRAME;
}
g_pStudioRender->DrawModel( NULL, modelInfo, pBoneToWorld, modelOrigin, drawFlags );
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->PopMatrix();
#endif
#if defined( USE_MATERIALSYSTEM )
pRenderContext->Flush( true );
#endif
#if defined( USE_VGUI )
vgui::ivgui()->RunFrame();
vgui::surface()->PaintTraverseEx( vgui::surface()->GetEmbeddedPanel() );
#endif
#if defined( USE_STUDIORENDER )
g_pStudioRender->EndFrame();
#endif
#if defined( USE_MATERIALSYSTEM )
m_pMaterialSystem->EndFrame();
m_pMaterialSystem->SwapBuffers();
#endif
}
//--------------------------------------------------------------------------------------
// Window Proc
//--------------------------------------------------------------------------------------
LRESULT CALLBACK WndProc( HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam )
{
switch ( iMsg )
{
case WM_CLOSE:
g_bActive = false;
break;
case WM_DESTROY:
PostQuitMessage( 0 );
return 0L;
case WM_XCONTROLLER_INSERTED:
Msg( "Port %d: Gamepad Activated\n", wParam );
break;
case WM_XCONTROLLER_UNPLUGGED:
Msg( "Port %d: Gamepad Unplugged\n", wParam );
break;
case WM_XCONTROLLER_KEY:
// wParam == key
// HIWORD( lParam ) = port
// LOWWORD( lParam ) = sample
Msg( "Port %d: Button %d %s\n", HIWORD( lParam ), wParam, LOWORD( lParam ) ? "Pressed" : "Released" );
switch ( wParam )
{
case XK_BUTTON_RTRIGGER:
if ( LOWORD( lParam ) )
{
g_zoom++;
}
break;
case XK_BUTTON_LTRIGGER:
if ( LOWORD( lParam ) )
{
g_zoom--;
}
break;
case XK_BUTTON_DOWN:
if ( LOWORD( lParam ) )
{
g_verticalPan += 2;
}
break;
case XK_BUTTON_UP:
if ( LOWORD( lParam ) )
{
g_verticalPan -= 2;
}
break;
case XK_BUTTON_LEFT:
if ( LOWORD( lParam ) )
{
g_horizontalPan += 2;
}
break;
case XK_BUTTON_RIGHT:
if ( LOWORD( lParam ) )
{
g_horizontalPan -= 2;
}
break;
case XK_STICK2_LEFT:
if ( LOWORD( lParam ) )
{
g_yaw += 5;
}
break;
case XK_STICK2_RIGHT:
if ( LOWORD( lParam ) )
{
g_yaw -= 5;
}
break;
case XK_BUTTON_A:
if ( LOWORD( lParam ) )
{
g_sequence++;
}
break;
case XK_BUTTON_B:
if ( LOWORD( lParam ) )
{
g_sequence--;
if ( g_sequence < 0 )
g_sequence = 0;
}
break;
case XK_BUTTON_Y:
if ( LOWORD( lParam ) )
{
g_bWireframe ^= 1;
}
break;
}
break;
case WM_KEYDOWN:
switch ( wParam )
{
case 'O':
g_zoom++;
break;
case 'P':
g_zoom--;
break;
case 'W':
g_verticalPan += 2;
break;
case 'S':
g_verticalPan -= 2;
break;
case 'A':
g_horizontalPan += 2;
break;
case 'D':
g_horizontalPan -= 2;
break;
case 'N':
g_sequence--;
if ( g_sequence < 0 )
g_sequence = 0;
break;
case 'M':
g_sequence++;
break;
}
break;
}
return DefWindowProc( hWnd, iMsg, wParam, lParam );
}
//--------------------------------------------------------------------------------------
// CreateMainWindow
//
//--------------------------------------------------------------------------------------
bool CTest360App::CreateMainWindow( int width, int height, bool fullscreen )
{
HWND hwnd;
WNDCLASSEX wndclass;
DWORD dwStyle, dwExStyle;
int x, y, sx, sy;
if ( ( hwnd = FindWindow( GetAppName(), GetAppName() ) ) != NULL )
{
SetForegroundWindow( hwnd );
return true;
}
wndclass.cbSize = sizeof (wndclass);
wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wndclass.lpfnWndProc = ::WndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = (HINSTANCE)GetAppInstance();
wndclass.hIcon = 0;
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hbrBackground = (HBRUSH)COLOR_GRAYTEXT;
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = GetAppName();
wndclass.hIconSm = 0;
if ( !RegisterClassEx( &wndclass ) )
{
Error( "Window class registration failed\n" );
return false;
}
if ( fullscreen )
{
dwExStyle = WS_EX_TOPMOST;
dwStyle = WS_POPUP | WS_VISIBLE;
}
else
{
dwExStyle = 0;
dwStyle = WS_CAPTION | WS_SYSMENU;
}
x = y = 0;
sx = width;
sy = height;
hwnd = CreateWindowEx(
dwExStyle,
GetAppName(), // window class name
GetAppName(), // window caption
dwStyle | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, // window style
x, // initial x position
y, // initial y position
sx, // initial x size
sy, // initial y size
NULL, // parent window handle
NULL, // window menu handle
(HINSTANCE)GetAppInstance(),// program instance handle
NULL); // creation parameter
if ( hwnd == NULL )
{
ChangeDisplaySettings( 0, 0 );
Error( "Window creation failed\n" );
return false;
}
m_hWnd = hwnd;
return true;
}
//-----------------------------------------------------------------------------
// Create
//-----------------------------------------------------------------------------
bool CTest360App::Create()
{
AppSystemInfo_t appSystems[] =
{
#if defined( USE_STUDIORENDER )
{ "datacache.dll", DATACACHE_INTERFACE_VERSION },
{ "datacache.dll", MDLCACHE_INTERFACE_VERSION },
#endif
#if defined( USE_MATERIALSYSTEM )
{ "materialsystem.dll", MATERIAL_SYSTEM_INTERFACE_VERSION },
#endif
#if defined( USE_STUDIORENDER )
{ "studiorender.dll", STUDIO_RENDER_INTERFACE_VERSION },
#endif
#if defined( USE_INPUTSYSTEM )
{ "inputsystem.dll", INPUTSYSTEM_INTERFACE_VERSION },
#endif
#if defined( USE_VGUI )
{ "vgui2.dll", VGUI_IVGUI_INTERFACE_VERSION },
{ "vguimatsurface.dll", VGUI_SURFACE_INTERFACE_VERSION },
#endif
#if defined( USE_STUDIORENDER )
{ "vphysics.dll", VPHYSICS_INTERFACE_VERSION },
#endif
{ "", "" }
};
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
SpewOutputFunc( g_DefaultSpewFunc );
#if defined( USE_FILESYSTEM )
// Add in the cvar factory
AppModule_t cvarModule = LoadModule( VStdLib_GetICVarFactory() );
AddSystem( cvarModule, VENGINE_CVAR_INTERFACE_VERSION );
#endif
#if defined( _X360 )
// vxconsole - true will block (legacy behavior)
XBX_InitConsoleMonitor( false );
#endif
if ( !AddSystems( appSystems ) )
return false;
#if defined( USE_FILESYSTEM )
m_pFileSystem = (IFileSystem*)FindSystem( FILESYSTEM_INTERFACE_VERSION );
if ( !m_pFileSystem )
{
Error( "Failed to find %s\n", FILESYSTEM_INTERFACE_VERSION );
return false;
}
#endif
#if defined( USE_VPHYSICS )
m_pCollision = (IPhysicsCollision*)FindSystem( VPHYSICS_COLLISION_INTERFACE_VERSION );
if ( !m_pCollision )
{
Error( "Failed to find %s\n", VPHYSICS_COLLISION_INTERFACE_VERSION );
return false;
}
#endif
#if defined( USE_MATERIALSYSTEM )
m_pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION );
if ( !m_pMaterialSystem )
{
Error( "Failed to find %s\n", MATERIAL_SYSTEM_INTERFACE_VERSION );
return false;
}
#if defined( _X360 )
m_pFileSystem->LoadModule( "shaderapidx9.dll" );
#endif
m_pMaterialSystem->SetShaderAPI( "shaderapidx9.dll" );
#endif
return true;
}
//-----------------------------------------------------------------------------
// PreInit
//-----------------------------------------------------------------------------
bool CTest360App::PreInit()
{
#if defined( USE_FILESYSTEM )
// Add paths...
if ( !SetupSearchPaths( NULL, false, true ) )
{
Error( "Failed to setup search paths\n" );
return false;
}
#endif
CreateInterfaceFn factory = GetFactory();
ConnectTier1Libraries( &factory, 1 );
ConnectTier2Libraries( &factory, 1 );
ConnectTier3Libraries( &factory, 1 );
// Create the main program window and our viewport
int w = 640;
int h = 480;
if ( IsX360() )
{
w = GetSystemMetrics( SM_CXSCREEN );
h = GetSystemMetrics( SM_CYSCREEN );
}
if ( !CreateMainWindow( w, h, false ) )
{
ChangeDisplaySettings( 0, 0 );
Error( "Unable to create main window\n" );
return false;
}
ShowWindow( m_hWnd, SW_SHOWNORMAL );
UpdateWindow( m_hWnd );
SetForegroundWindow( m_hWnd );
SetFocus( m_hWnd );
return true;
}
//-----------------------------------------------------------------------------
// Destroy
//-----------------------------------------------------------------------------
void CTest360App::Destroy()
{
}
//-----------------------------------------------------------------------------
// Purpose: Setup all our VGUI info
//-----------------------------------------------------------------------------
#if defined( USE_VGUI )
static CreateInterfaceFn s_pFactoryList[3];
void *VGuiFactory( const char *pName, int *pReturnCode )
{
for ( int i = 0; i < ARRAYSIZE( s_pFactoryList ); ++i )
{
void *pInterface = s_pFactoryList[i]( pName, pReturnCode );
if ( pInterface )
return pInterface;
}
return NULL;
}
int CTest360App::InitializeVGUI( void )
{
s_pFactoryList[0] = Sys_GetFactory( m_pFileSystem->LoadModule( "filesystem_stdio" ) );
s_pFactoryList[1] = Sys_GetFactory( m_pFileSystem->LoadModule( "vguimatsurface" ) );
s_pFactoryList[2] = Sys_GetFactory( m_pFileSystem->LoadModule( "vgui2" ) );
int factorycount = ARRAYSIZE( s_pFactoryList );
if ( !vgui::VGui_InitInterfacesList( "test360", s_pFactoryList, factorycount ) )
return 3;
vgui::ivgui()->Connect( VGuiFactory );
vgui::ivgui()->Init();
vgui::ivgui()->SetSleep(false);
// Init the surface
vgui::Panel *pPanel = new vgui::Panel( NULL, "TopPanel" );
pPanel->SetBounds( 0, 0, m_nWidth, m_nHeight );
pPanel->SetPaintBackgroundEnabled( false );
pPanel->SetVisible(true);
vgui::surface()->SetEmbeddedPanel(pPanel->GetVPanel());
// load the scheme
vgui::scheme()->LoadSchemeFromFile( "resource/clientscheme.res", NULL );
// localization
//vgui::localize()->AddFile( "resource/vgui_%language%.txt" );
// Start vgui
vgui::ivgui()->Start();
// add a panel
m_pMainPanel = new vgui::Panel( pPanel, "MainPanel" );
SETUP_PANEL( m_pMainPanel );
m_pMainPanel->SetBounds( 30, 30, 200, 100 );
m_pMainPanel->SetBgColor( Color(255,255,0,255) );
// add text
vgui::Label *pLabel = new vgui::Label( m_pMainPanel, "Text", L"" );
SETUP_PANEL( pLabel );
vgui::HScheme scheme = vgui::scheme()->GetScheme( "ClientScheme" );
// vgui::HFont hFont = vgui::scheme()->GetIScheme(scheme)->GetFont( "BudgetLabel" );
// pLabel->SetFont( hFont );
pLabel->SetText( L"This is text" );
pLabel->SetFgColor( Color(0,0,0,255) );
return 0;
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Stop VGUI
//-----------------------------------------------------------------------------
#if defined( USE_VGUI )
void CTest360App::ShutdownVGUI( void )
{
delete m_pMainPanel;
// Shutdown
vgui::surface()->Shutdown();
}
#endif
//-----------------------------------------------------------------------------
// Main
//-----------------------------------------------------------------------------
int CTest360App::Main()
{
#if defined( USE_MATERIALSYSTEM )
if ( !SetupMaterialSystem() )
{
return 0;
}
#endif
#if defined( USE_STUDIORENDER )
if ( !SetupStudioRender() )
{
return 0;
}
#endif
#if defined( USE_VGUI )
int ret = InitializeVGUI();
if ( ret != 0 )
return ret;
#endif
const char *pArgVal;
const char* pModelName = "models\\alyx.mdl";
if ( CommandLine()->CheckParm( "-model", &pArgVal ) )
{
pModelName = pArgVal;
}
#if defined( USE_STUDIORENDER )
// the easiest model to load - no anims
//const char* pModelName = "models\\items\\item_item_crate.mdl";
if ( !LoadModel( pModelName ) )
{
return 0;
}
#endif
MSG msg;
while ( g_bActive == TRUE )
{
while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
#if defined( USE_INPUTSYSTEM )
g_pInputSystem->PollInputState();
#endif
RenderScene();
}
#if defined( USE_VGUI )
ShutdownVGUI();
#endif
return 0;
}