mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-23 06:36:54 +00:00
982 lines
23 KiB
C++
982 lines
23 KiB
C++
//========= 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;
|
|
}
|