（三）代码b.0：hellovr_opengl

    我主要也是看了各个主要函数调用关系，特别是和显示有关的，因为改代码基本就是在这些地方该。

    https://github.com/ValveSoftware/openvr/blob/master/samples/hellovr_opengl/hellovr_opengl_main.cpp

//========= Copyright Valve Corporation ============//



#include 

#include 

#include 

#if defined( OSX )

#include 

#include 

#include 

// Apple's version of glut.h #undef's APIENTRY, redefine it

#define APIENTRY

#else

#include 

#endif

#include 

#include 

#include 



#include 



#include "shared/lodepng.h"

#include "shared/Matrices.h"

#include "shared/pathtools.h"



#if defined(POSIX)

#include "unistd.h"

#endif



#ifndef _WIN32

#define APIENTRY

#endif



#ifndef _countof

#define _countof(x) (sizeof(x)/sizeof((x)[0]))

#endif



void ThreadSleep( unsigned long nMilliseconds )

{

#if defined(_WIN32)

	::Sleep( nMilliseconds );

#elif defined(POSIX)

	usleep( nMilliseconds * 1000 );

#endif

}



class CGLRenderModel

{

public:

	CGLRenderModel( const std::string & sRenderModelName );

	~CGLRenderModel();



	bool BInit( const vr::RenderModel_t & vrModel, const vr::RenderModel_TextureMap_t & vrDiffuseTexture );

	void Cleanup();

	void Draw();

	const std::string & GetName() const { return m_sModelName; }



private:

	GLuint m_glVertBuffer;

	GLuint m_glIndexBuffer;

	GLuint m_glVertArray;

	GLuint m_glTexture;

	GLsizei m_unVertexCount;

	std::string m_sModelName;

};



static bool g_bPrintf = true;



//-----------------------------------------------------------------------------

// Purpose:

//------------------------------------------------------------------------------

class CMainApplication

{

public:

	CMainApplication( int argc, char *argv[] );

	virtual ~CMainApplication();



	bool BInit();

	bool BInitGL();

	bool BInitCompositor();



	void SetupRenderModels();



	void Shutdown();



	void RunMainLoop();

	bool HandleInput();

	void ProcessVREvent( const vr::VREvent_t & event );

	void RenderFrame();



	bool SetupTexturemaps();



	void SetupScene();

	void AddCubeToScene( Matrix4 mat, std::vector &vertdata );

	void AddCubeVertex( float fl0, float fl1, float fl2, float fl3, float fl4, std::vector &vertdata );



	void RenderControllerAxes();



	bool SetupStereoRenderTargets();

	void SetupCompanionWindow();

	void SetupCameras();



	void RenderStereoTargets();

	void RenderCompanionWindow();

	void RenderScene( vr::Hmd_Eye nEye );



	Matrix4 GetHMDMatrixProjectionEye( vr::Hmd_Eye nEye );

	Matrix4 GetHMDMatrixPoseEye( vr::Hmd_Eye nEye );

	Matrix4 GetCurrentViewProjectionMatrix( vr::Hmd_Eye nEye );

	void UpdateHMDMatrixPose();



	Matrix4 ConvertSteamVRMatrixToMatrix4( const vr::HmdMatrix34_t &matPose );



	GLuint CompileGLShader( const char *pchShaderName, const char *pchVertexShader, const char *pchFragmentShader );

	bool CreateAllShaders();



	void SetupRenderModelForTrackedDevice( vr::TrackedDeviceIndex_t unTrackedDeviceIndex );

	CGLRenderModel *FindOrLoadRenderModel( const char *pchRenderModelName );



private: 

	bool m_bDebugOpenGL;

	bool m_bVerbose;

	bool m_bPerf;

	bool m_bVblank;

	bool m_bGlFinishHack;



	vr::IVRSystem *m_pHMD;

	vr::IVRRenderModels *m_pRenderModels;

	std::string m_strDriver;

	std::string m_strDisplay;

	vr::TrackedDevicePose_t m_rTrackedDevicePose[ vr::k_unMaxTrackedDeviceCount ];

	Matrix4 m_rmat4DevicePose[ vr::k_unMaxTrackedDeviceCount ];

	bool m_rbShowTrackedDevice[ vr::k_unMaxTrackedDeviceCount ];



private: // SDL bookkeeping

	SDL_Window *m_pCompanionWindow;

	uint32_t m_nCompanionWindowWidth;

	uint32_t m_nCompanionWindowHeight;



	SDL_GLContext m_pContext;



private: // OpenGL bookkeeping

	int m_iTrackedControllerCount;

	int m_iTrackedControllerCount_Last;

	int m_iValidPoseCount;

	int m_iValidPoseCount_Last;

	bool m_bShowCubes;



	std::string m_strPoseClasses;                            // what classes we saw poses for this frame

	char m_rDevClassChar[ vr::k_unMaxTrackedDeviceCount ];   // for each device, a character representing its class



	int m_iSceneVolumeWidth;

	int m_iSceneVolumeHeight;

	int m_iSceneVolumeDepth;

	float m_fScaleSpacing;

	float m_fScale;

	

	int m_iSceneVolumeInit;                                  // if you want something other than the default 20x20x20

	

	float m_fNearClip;

	float m_fFarClip;



	GLuint m_iTexture;



	unsigned int m_uiVertcount;



	GLuint m_glSceneVertBuffer;

	GLuint m_unSceneVAO;

	GLuint m_unCompanionWindowVAO;

	GLuint m_glCompanionWindowIDVertBuffer;

	GLuint m_glCompanionWindowIDIndexBuffer;

	unsigned int m_uiCompanionWindowIndexSize;



	GLuint m_glControllerVertBuffer;

	GLuint m_unControllerVAO;

	unsigned int m_uiControllerVertcount;



	Matrix4 m_mat4HMDPose;

	Matrix4 m_mat4eyePosLeft;

	Matrix4 m_mat4eyePosRight;



	Matrix4 m_mat4ProjectionCenter;

	Matrix4 m_mat4ProjectionLeft;

	Matrix4 m_mat4ProjectionRight;



	struct VertexDataScene

	{

		Vector3 position;

		Vector2 texCoord;

	};



	struct VertexDataWindow

	{

		Vector2 position;

		Vector2 texCoord;



		VertexDataWindow( const Vector2 & pos, const Vector2 tex ) :  position(pos), texCoord(tex) {	}

	};



	GLuint m_unSceneProgramID;

	GLuint m_unCompanionWindowProgramID;

	GLuint m_unControllerTransformProgramID;

	GLuint m_unRenderModelProgramID;



	GLint m_nSceneMatrixLocation;

	GLint m_nControllerMatrixLocation;

	GLint m_nRenderModelMatrixLocation;



	struct FramebufferDesc

	{

		GLuint m_nDepthBufferId;

		GLuint m_nRenderTextureId;

		GLuint m_nRenderFramebufferId;

		GLuint m_nResolveTextureId;

		GLuint m_nResolveFramebufferId;

	};

	FramebufferDesc leftEyeDesc;

	FramebufferDesc rightEyeDesc;



	bool CreateFrameBuffer( int nWidth, int nHeight, FramebufferDesc &framebufferDesc );

	

	uint32_t m_nRenderWidth;

	uint32_t m_nRenderHeight;



	std::vector< CGLRenderModel * > m_vecRenderModels;

	CGLRenderModel *m_rTrackedDeviceToRenderModel[ vr::k_unMaxTrackedDeviceCount ];

};



//-----------------------------------------------------------------------------

// Purpose: Outputs a set of optional arguments to debugging output, using

//          the printf format setting specified in fmt*.

//-----------------------------------------------------------------------------

void dprintf( const char *fmt, ... )

{

	va_list args;

	char buffer[ 2048 ];



	va_start( args, fmt );

	vsprintf_s( buffer, fmt, args );

	va_end( args );



	if ( g_bPrintf )

		printf( "%s", buffer );



	OutputDebugStringA( buffer );

}



//-----------------------------------------------------------------------------

// Purpose: Constructor

//-----------------------------------------------------------------------------

CMainApplication::CMainApplication( int argc, char *argv[] )

	: m_pCompanionWindow(NULL)

	, m_pContext(NULL)

	, m_nCompanionWindowWidth( 640 )

	, m_nCompanionWindowHeight( 320 )

	, m_unSceneProgramID( 0 )

	, m_unCompanionWindowProgramID( 0 )

	, m_unControllerTransformProgramID( 0 )

	, m_unRenderModelProgramID( 0 )

	, m_pHMD( NULL )

	, m_pRenderModels( NULL )

	, m_bDebugOpenGL( false )

	, m_bVerbose( false )

	, m_bPerf( false )

	, m_bVblank( false )

	, m_bGlFinishHack( true )

	, m_glControllerVertBuffer( 0 )

	, m_unControllerVAO( 0 )

	, m_unSceneVAO( 0 )

	, m_nSceneMatrixLocation( -1 )

	, m_nControllerMatrixLocation( -1 )

	, m_nRenderModelMatrixLocation( -1 )

	, m_iTrackedControllerCount( 0 )

	, m_iTrackedControllerCount_Last( -1 )

	, m_iValidPoseCount( 0 )

	, m_iValidPoseCount_Last( -1 )

	, m_iSceneVolumeInit( 20 )

	, m_strPoseClasses("")

	, m_bShowCubes( true )

{



	for( int i = 1; i < argc; i++ )

	{

		if( !stricmp( argv[i], "-gldebug" ) )

		{

			m_bDebugOpenGL = true;

		}

		else if( !stricmp( argv[i], "-verbose" ) )

		{

			m_bVerbose = true;

		}

		else if( !stricmp( argv[i], "-novblank" ) )

		{

			m_bVblank = false;

		}

		else if( !stricmp( argv[i], "-noglfinishhack" ) )

		{

			m_bGlFinishHack = false;

		}

		else if( !stricmp( argv[i], "-noprintf" ) )

		{

			g_bPrintf = false;

		}

		else if ( !stricmp( argv[i], "-cubevolume" ) && ( argc > i + 1 ) && ( *argv[ i + 1 ] != '-' ) )

		{

			m_iSceneVolumeInit = atoi( argv[ i + 1 ] );

			i++;

		}

	}

	// other initialization tasks are done in BInit

	memset(m_rDevClassChar, 0, sizeof(m_rDevClassChar));

};





//-----------------------------------------------------------------------------

// Purpose: Destructor

//-----------------------------------------------------------------------------

CMainApplication::~CMainApplication()

{

	// work is done in Shutdown

	dprintf( "Shutdown" );

}





//-----------------------------------------------------------------------------

// Purpose: Helper to get a string from a tracked device property and turn it

//			into a std::string

//-----------------------------------------------------------------------------

std::string GetTrackedDeviceString( vr::IVRSystem *pHmd, vr::TrackedDeviceIndex_t unDevice, vr::TrackedDeviceProperty prop, vr::TrackedPropertyError *peError = NULL )

{

	uint32_t unRequiredBufferLen = pHmd->GetStringTrackedDeviceProperty( unDevice, prop, NULL, 0, peError );

	if( unRequiredBufferLen == 0 )

		return "";



	char *pchBuffer = new char[ unRequiredBufferLen ];

	unRequiredBufferLen = pHmd->GetStringTrackedDeviceProperty( unDevice, prop, pchBuffer, unRequiredBufferLen, peError );

	std::string sResult = pchBuffer;

	delete [] pchBuffer;

	return sResult;

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

bool CMainApplication::BInit()

{

	if ( SDL_Init( SDL_INIT_VIDEO | SDL_INIT_TIMER ) < 0 )

	{

		printf("%s - SDL could not initialize! SDL Error: %s\n", __FUNCTION__, SDL_GetError());

		return false;

	}



	// Loading the SteamVR Runtime

	vr::EVRInitError eError = vr::VRInitError_None;

	m_pHMD = vr::VR_Init( &eError, vr::VRApplication_Scene );



	if ( eError != vr::VRInitError_None )

	{

		m_pHMD = NULL;

		char buf[1024];

		sprintf_s( buf, sizeof( buf ), "Unable to init VR runtime: %s", vr::VR_GetVRInitErrorAsEnglishDescription( eError ) );

		SDL_ShowSimpleMessageBox( SDL_MESSAGEBOX_ERROR, "VR_Init Failed", buf, NULL );

		return false;

	}





	m_pRenderModels = (vr::IVRRenderModels *)vr::VR_GetGenericInterface( vr::IVRRenderModels_Version, &eError );

	if( !m_pRenderModels )

	{

		m_pHMD = NULL;

		vr::VR_Shutdown();



		char buf[1024];

		sprintf_s( buf, sizeof( buf ), "Unable to get render model interface: %s", vr::VR_GetVRInitErrorAsEnglishDescription( eError ) );

		SDL_ShowSimpleMessageBox( SDL_MESSAGEBOX_ERROR, "VR_Init Failed", buf, NULL );

		return false;

	}



	int nWindowPosX = 700;

	int nWindowPosY = 100;

	Uint32 unWindowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;



	SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 4 );

	SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 1 );

	//SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY );

	SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE );



	SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, 0 );

	SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, 0 );

	if( m_bDebugOpenGL )

		SDL_GL_SetAttribute( SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG );



	m_pCompanionWindow = SDL_CreateWindow( "hellovr", nWindowPosX, nWindowPosY, m_nCompanionWindowWidth, m_nCompanionWindowHeight, unWindowFlags );

	if (m_pCompanionWindow == NULL)

	{

		printf( "%s - Window could not be created! SDL Error: %s\n", __FUNCTION__, SDL_GetError() );

		return false;

	}



	m_pContext = SDL_GL_CreateContext(m_pCompanionWindow);

	if (m_pContext == NULL)

	{

		printf( "%s - OpenGL context could not be created! SDL Error: %s\n", __FUNCTION__, SDL_GetError() );

		return false;

	}



	glewExperimental = GL_TRUE;

	GLenum nGlewError = glewInit();

	if (nGlewError != GLEW_OK)

	{

		printf( "%s - Error initializing GLEW! %s\n", __FUNCTION__, glewGetErrorString( nGlewError ) );

		return false;

	}

	glGetError(); // to clear the error caused deep in GLEW



	if ( SDL_GL_SetSwapInterval( m_bVblank ? 1 : 0 ) < 0 )

	{

		printf( "%s - Warning: Unable to set VSync! SDL Error: %s\n", __FUNCTION__, SDL_GetError() );

		return false;

	}





	m_strDriver = "No Driver";

	m_strDisplay = "No Display";



	m_strDriver = GetTrackedDeviceString( m_pHMD, vr::k_unTrackedDeviceIndex_Hmd, vr::Prop_TrackingSystemName_String );

	m_strDisplay = GetTrackedDeviceString( m_pHMD, vr::k_unTrackedDeviceIndex_Hmd, vr::Prop_SerialNumber_String );



	std::string strWindowTitle = "hellovr - " + m_strDriver + " " + m_strDisplay;

	SDL_SetWindowTitle( m_pCompanionWindow, strWindowTitle.c_str() );

	

	// cube array

 	m_iSceneVolumeWidth = m_iSceneVolumeInit;

 	m_iSceneVolumeHeight = m_iSceneVolumeInit;

 	m_iSceneVolumeDepth = m_iSceneVolumeInit;

 		

 	m_fScale = 0.3f;

 	m_fScaleSpacing = 4.0f;

 

 	m_fNearClip = 0.1f;

 	m_fFarClip = 30.0f;

 

 	m_iTexture = 0;

 	m_uiVertcount = 0;

 

// 		m_MillisecondsTimer.start(1, this);

// 		m_SecondsTimer.start(1000, this);

	

	if (!BInitGL())

	{

		printf("%s - Unable to initialize OpenGL!\n", __FUNCTION__);

		return false;

	}



	if (!BInitCompositor())

	{

		printf("%s - Failed to initialize VR Compositor!\n", __FUNCTION__);

		return false;

	}



	return true;

}





//-----------------------------------------------------------------------------

// Purpose: Outputs the string in message to debugging output.

//          All other parameters are ignored.

//          Does not return any meaningful value or reference.

//-----------------------------------------------------------------------------

void APIENTRY DebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char* message, const void* userParam)

{

	dprintf( "GL Error: %s\n", message );

}





//-----------------------------------------------------------------------------

// Purpose: Initialize OpenGL. Returns true if OpenGL has been successfully

//          initialized, false if shaders could not be created.

//          If failure occurred in a module other than shaders, the function

//          may return true or throw an error. 

//-----------------------------------------------------------------------------

bool CMainApplication::BInitGL()

{

	if( m_bDebugOpenGL )

	{

		glDebugMessageCallback( (GLDEBUGPROC)DebugCallback, nullptr);

		glDebugMessageControl( GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE );

		glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);

	}



	if( !CreateAllShaders() )

		return false;



	SetupTexturemaps();

	SetupScene();

	SetupCameras();

	SetupStereoRenderTargets();

	SetupCompanionWindow();

	SetupRenderModels();



	return true;

}





//-----------------------------------------------------------------------------

// Purpose: Initialize Compositor. Returns true if the compositor was

//          successfully initialized, false otherwise.

//-----------------------------------------------------------------------------

bool CMainApplication::BInitCompositor()

{

	vr::EVRInitError peError = vr::VRInitError_None;



	if ( !vr::VRCompositor() )

	{

		printf( "Compositor initialization failed. See log file for details\n" );

		return false;

	}



	return true;

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

void CMainApplication::Shutdown()

{

	if( m_pHMD )

	{

		vr::VR_Shutdown();

		m_pHMD = NULL;

	}



	for( std::vector< CGLRenderModel * >::iterator i = m_vecRenderModels.begin(); i != m_vecRenderModels.end(); i++ )

	{

		delete (*i);

	}

	m_vecRenderModels.clear();

	

	if( m_pContext )

	{

		if( m_bDebugOpenGL )

		{

			glDebugMessageControl( GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_FALSE );

			glDebugMessageCallback(nullptr, nullptr);

		}

		glDeleteBuffers(1, &m_glSceneVertBuffer);



		if ( m_unSceneProgramID )

		{

			glDeleteProgram( m_unSceneProgramID );

		}

		if ( m_unControllerTransformProgramID )

		{

			glDeleteProgram( m_unControllerTransformProgramID );

		}

		if ( m_unRenderModelProgramID )

		{

			glDeleteProgram( m_unRenderModelProgramID );

		}

		if ( m_unCompanionWindowProgramID )

		{

			glDeleteProgram( m_unCompanionWindowProgramID );

		}



		glDeleteRenderbuffers( 1, &leftEyeDesc.m_nDepthBufferId );

		glDeleteTextures( 1, &leftEyeDesc.m_nRenderTextureId );

		glDeleteFramebuffers( 1, &leftEyeDesc.m_nRenderFramebufferId );

		glDeleteTextures( 1, &leftEyeDesc.m_nResolveTextureId );

		glDeleteFramebuffers( 1, &leftEyeDesc.m_nResolveFramebufferId );



		glDeleteRenderbuffers( 1, &rightEyeDesc.m_nDepthBufferId );

		glDeleteTextures( 1, &rightEyeDesc.m_nRenderTextureId );

		glDeleteFramebuffers( 1, &rightEyeDesc.m_nRenderFramebufferId );

		glDeleteTextures( 1, &rightEyeDesc.m_nResolveTextureId );

		glDeleteFramebuffers( 1, &rightEyeDesc.m_nResolveFramebufferId );



		if( m_unCompanionWindowVAO != 0 )

		{

			glDeleteVertexArrays( 1, &m_unCompanionWindowVAO );

		}

		if( m_unSceneVAO != 0 )

		{

			glDeleteVertexArrays( 1, &m_unSceneVAO );

		}

		if( m_unControllerVAO != 0 )

		{

			glDeleteVertexArrays( 1, &m_unControllerVAO );

		}

	}



	if( m_pCompanionWindow )

	{

		SDL_DestroyWindow(m_pCompanionWindow);

		m_pCompanionWindow = NULL;

	}



	SDL_Quit();

}



//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

bool CMainApplication::HandleInput()

{

	SDL_Event sdlEvent;

	bool bRet = false;



	while ( SDL_PollEvent( &sdlEvent ) != 0 )

	{

		if ( sdlEvent.type == SDL_QUIT )

		{

			bRet = true;

		}

		else if ( sdlEvent.type == SDL_KEYDOWN )

		{

			if ( sdlEvent.key.keysym.sym == SDLK_ESCAPE 

			     || sdlEvent.key.keysym.sym == SDLK_q )

			{

				bRet = true;

			}

			if( sdlEvent.key.keysym.sym == SDLK_c )

			{

				m_bShowCubes = !m_bShowCubes;

			}

		}

	}



	// Process SteamVR events

	vr::VREvent_t event;

	while( m_pHMD->PollNextEvent( &event, sizeof( event ) ) )

	{

		ProcessVREvent( event );

	}



	// Process SteamVR controller state

	for( vr::TrackedDeviceIndex_t unDevice = 0; unDevice < vr::k_unMaxTrackedDeviceCount; unDevice++ )

	{

		vr::VRControllerState_t state;

		if( m_pHMD->GetControllerState( unDevice, &state, sizeof(state) ) )

		{

			m_rbShowTrackedDevice[ unDevice ] = state.ulButtonPressed == 0;

		}

	}



	return bRet;

}



//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

void CMainApplication::RunMainLoop()

{

	bool bQuit = false;



	SDL_StartTextInput();

	SDL_ShowCursor( SDL_DISABLE );



	while ( !bQuit )

	{

		bQuit = HandleInput();



		RenderFrame();

	}



	SDL_StopTextInput();

}





//-----------------------------------------------------------------------------

// Purpose: Processes a single VR event

//-----------------------------------------------------------------------------

void CMainApplication::ProcessVREvent( const vr::VREvent_t & event )

{

	switch( event.eventType )

	{

	case vr::VREvent_TrackedDeviceActivated:

		{

			SetupRenderModelForTrackedDevice( event.trackedDeviceIndex );

			dprintf( "Device %u attached. Setting up render model.\n", event.trackedDeviceIndex );

		}

		break;

	case vr::VREvent_TrackedDeviceDeactivated:

		{

			dprintf( "Device %u detached.\n", event.trackedDeviceIndex );

		}

		break;

	case vr::VREvent_TrackedDeviceUpdated:

		{

			dprintf( "Device %u updated.\n", event.trackedDeviceIndex );

		}

		break;

	}

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

void CMainApplication::RenderFrame()

{

	// for now as fast as possible

	if ( m_pHMD )

	{

		RenderControllerAxes();

		RenderStereoTargets();

		RenderCompanionWindow();



		vr::Texture_t leftEyeTexture = {(void*)(uintptr_t)leftEyeDesc.m_nResolveTextureId, vr::TextureType_OpenGL, vr::ColorSpace_Gamma };

		vr::VRCompositor()->Submit(vr::Eye_Left, &leftEyeTexture );

		vr::Texture_t rightEyeTexture = {(void*)(uintptr_t)rightEyeDesc.m_nResolveTextureId, vr::TextureType_OpenGL, vr::ColorSpace_Gamma };

		vr::VRCompositor()->Submit(vr::Eye_Right, &rightEyeTexture );

	}



	if ( m_bVblank && m_bGlFinishHack )

	{

		//$ HACKHACK. From gpuview profiling, it looks like there is a bug where two renders and a present

		// happen right before and after the vsync causing all kinds of jittering issues. This glFinish()

		// appears to clear that up. Temporary fix while I try to get nvidia to investigate this problem.

		// 1/29/2014 mikesart

		glFinish();

	}



	// SwapWindow

	{

		SDL_GL_SwapWindow( m_pCompanionWindow );

	}



	// Clear

	{

		// We want to make sure the glFinish waits for the entire present to complete, not just the submission

		// of the command. So, we do a clear here right here so the glFinish will wait fully for the swap.

		glClearColor( 0, 0, 0, 1 );

		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

	}



	// Flush and wait for swap.

	if ( m_bVblank )

	{

		glFlush();

		glFinish();

	}



	// Spew out the controller and pose count whenever they change.

	if ( m_iTrackedControllerCount != m_iTrackedControllerCount_Last || m_iValidPoseCount != m_iValidPoseCount_Last )

	{

		m_iValidPoseCount_Last = m_iValidPoseCount;

		m_iTrackedControllerCount_Last = m_iTrackedControllerCount;

		

		dprintf( "PoseCount:%d(%s) Controllers:%d\n", m_iValidPoseCount, m_strPoseClasses.c_str(), m_iTrackedControllerCount );

	}



	UpdateHMDMatrixPose();

}





//-----------------------------------------------------------------------------

// Purpose: Compiles a GL shader program and returns the handle. Returns 0 if

//			the shader couldn't be compiled for some reason.

//-----------------------------------------------------------------------------

GLuint CMainApplication::CompileGLShader( const char *pchShaderName, const char *pchVertexShader, const char *pchFragmentShader )

{

	GLuint unProgramID = glCreateProgram();



	GLuint nSceneVertexShader = glCreateShader(GL_VERTEX_SHADER);

	glShaderSource( nSceneVertexShader, 1, &pchVertexShader, NULL);

	glCompileShader( nSceneVertexShader );



	GLint vShaderCompiled = GL_FALSE;

	glGetShaderiv( nSceneVertexShader, GL_COMPILE_STATUS, &vShaderCompiled);

	if ( vShaderCompiled != GL_TRUE)

	{

		dprintf("%s - Unable to compile vertex shader %d!\n", pchShaderName, nSceneVertexShader);

		glDeleteProgram( unProgramID );

		glDeleteShader( nSceneVertexShader );

		return 0;

	}

	glAttachShader( unProgramID, nSceneVertexShader);

	glDeleteShader( nSceneVertexShader ); // the program hangs onto this once it's attached



	GLuint  nSceneFragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

	glShaderSource( nSceneFragmentShader, 1, &pchFragmentShader, NULL);

	glCompileShader( nSceneFragmentShader );



	GLint fShaderCompiled = GL_FALSE;

	glGetShaderiv( nSceneFragmentShader, GL_COMPILE_STATUS, &fShaderCompiled);

	if (fShaderCompiled != GL_TRUE)

	{

		dprintf("%s - Unable to compile fragment shader %d!\n", pchShaderName, nSceneFragmentShader );

		glDeleteProgram( unProgramID );

		glDeleteShader( nSceneFragmentShader );

		return 0;	

	}



	glAttachShader( unProgramID, nSceneFragmentShader );

	glDeleteShader( nSceneFragmentShader ); // the program hangs onto this once it's attached



	glLinkProgram( unProgramID );



	GLint programSuccess = GL_TRUE;

	glGetProgramiv( unProgramID, GL_LINK_STATUS, &programSuccess);

	if ( programSuccess != GL_TRUE )

	{

		dprintf("%s - Error linking program %d!\n", pchShaderName, unProgramID);

		glDeleteProgram( unProgramID );

		return 0;

	}



	glUseProgram( unProgramID );

	glUseProgram( 0 );



	return unProgramID;

}





//-----------------------------------------------------------------------------

// Purpose: Creates all the shaders used by HelloVR SDL

//-----------------------------------------------------------------------------

bool CMainApplication::CreateAllShaders()

{

	m_unSceneProgramID = CompileGLShader( 

		"Scene",



		// Vertex Shader

		"#version 410\n"

		"uniform mat4 matrix;\n"

		"layout(location = 0) in vec4 position;\n"

		"layout(location = 1) in vec2 v2UVcoordsIn;\n"

		"layout(location = 2) in vec3 v3NormalIn;\n"

		"out vec2 v2UVcoords;\n"

		"void main()\n"

		"{\n"

		"	v2UVcoords = v2UVcoordsIn;\n"

		"	gl_Position = matrix * position;\n"

		"}\n",



		// Fragment Shader

		"#version 410 core\n"

		"uniform sampler2D mytexture;\n"

		"in vec2 v2UVcoords;\n"

		"out vec4 outputColor;\n"

		"void main()\n"

		"{\n"

		"   outputColor = texture(mytexture, v2UVcoords);\n"

		"}\n"

		);

	m_nSceneMatrixLocation = glGetUniformLocation( m_unSceneProgramID, "matrix" );

	if( m_nSceneMatrixLocation == -1 )

	{

		dprintf( "Unable to find matrix uniform in scene shader\n" );

		return false;

	}



	m_unControllerTransformProgramID = CompileGLShader(

		"Controller",



		// vertex shader

		"#version 410\n"

		"uniform mat4 matrix;\n"

		"layout(location = 0) in vec4 position;\n"

		"layout(location = 1) in vec3 v3ColorIn;\n"

		"out vec4 v4Color;\n"

		"void main()\n"

		"{\n"

		"	v4Color.xyz = v3ColorIn; v4Color.a = 1.0;\n"

		"	gl_Position = matrix * position;\n"

		"}\n",



		// fragment shader

		"#version 410\n"

		"in vec4 v4Color;\n"

		"out vec4 outputColor;\n"

		"void main()\n"

		"{\n"

		"   outputColor = v4Color;\n"

		"}\n"

		);

	m_nControllerMatrixLocation = glGetUniformLocation( m_unControllerTransformProgramID, "matrix" );

	if( m_nControllerMatrixLocation == -1 )

	{

		dprintf( "Unable to find matrix uniform in controller shader\n" );

		return false;

	}



	m_unRenderModelProgramID = CompileGLShader( 

		"render model",



		// vertex shader

		"#version 410\n"

		"uniform mat4 matrix;\n"

		"layout(location = 0) in vec4 position;\n"

		"layout(location = 1) in vec3 v3NormalIn;\n"

		"layout(location = 2) in vec2 v2TexCoordsIn;\n"

		"out vec2 v2TexCoord;\n"

		"void main()\n"

		"{\n"

		"	v2TexCoord = v2TexCoordsIn;\n"

		"	gl_Position = matrix * vec4(position.xyz, 1);\n"

		"}\n",



		//fragment shader

		"#version 410 core\n"

		"uniform sampler2D diffuse;\n"

		"in vec2 v2TexCoord;\n"

		"out vec4 outputColor;\n"

		"void main()\n"

		"{\n"

		"   outputColor = texture( diffuse, v2TexCoord);\n"

		"}\n"



		);

	m_nRenderModelMatrixLocation = glGetUniformLocation( m_unRenderModelProgramID, "matrix" );

	if( m_nRenderModelMatrixLocation == -1 )

	{

		dprintf( "Unable to find matrix uniform in render model shader\n" );

		return false;

	}



	m_unCompanionWindowProgramID = CompileGLShader(

		"CompanionWindow",



		// vertex shader

		"#version 410 core\n"

		"layout(location = 0) in vec4 position;\n"

		"layout(location = 1) in vec2 v2UVIn;\n"

		"noperspective out vec2 v2UV;\n"

		"void main()\n"

		"{\n"

		"	v2UV = v2UVIn;\n"

		"	gl_Position = position;\n"

		"}\n",



		// fragment shader

		"#version 410 core\n"

		"uniform sampler2D mytexture;\n"

		"noperspective in vec2 v2UV;\n"

		"out vec4 outputColor;\n"

		"void main()\n"

		"{\n"

		"		outputColor = texture(mytexture, v2UV);\n"

		"}\n"

		);



	return m_unSceneProgramID != 0 

		&& m_unControllerTransformProgramID != 0

		&& m_unRenderModelProgramID != 0

		&& m_unCompanionWindowProgramID != 0;

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

bool CMainApplication::SetupTexturemaps()

{

	std::string sExecutableDirectory = Path_StripFilename( Path_GetExecutablePath() );

	std::string strFullPath = Path_MakeAbsolute( "../cube_texture.png", sExecutableDirectory );

	

	std::vector imageRGBA;

	unsigned nImageWidth, nImageHeight;

	unsigned nError = lodepng::decode( imageRGBA, nImageWidth, nImageHeight, strFullPath.c_str() );

	

	if ( nError != 0 )

		return false;



	glGenTextures(1, &m_iTexture );

	glBindTexture( GL_TEXTURE_2D, m_iTexture );



	glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, nImageWidth, nImageHeight,

		0, GL_RGBA, GL_UNSIGNED_BYTE, &imageRGBA[0] );



	glGenerateMipmap(GL_TEXTURE_2D);



	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );



	GLfloat fLargest;

	glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fLargest);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest);

	 	

	glBindTexture( GL_TEXTURE_2D, 0 );



	return ( m_iTexture != 0 );

}





//-----------------------------------------------------------------------------

// Purpose: create a sea of cubes

//-----------------------------------------------------------------------------

void CMainApplication::SetupScene()

{

	if ( !m_pHMD )

		return;



	std::vector vertdataarray;



	Matrix4 matScale;

	matScale.scale( m_fScale, m_fScale, m_fScale );

	Matrix4 matTransform;

	matTransform.translate(

		-( (float)m_iSceneVolumeWidth * m_fScaleSpacing ) / 2.f,

		-( (float)m_iSceneVolumeHeight * m_fScaleSpacing ) / 2.f,

		-( (float)m_iSceneVolumeDepth * m_fScaleSpacing ) / 2.f);

	

	Matrix4 mat = matScale * matTransform;



	for( int z = 0; z< m_iSceneVolumeDepth; z++ )

	{

		for( int y = 0; y< m_iSceneVolumeHeight; y++ )

		{

			for( int x = 0; x< m_iSceneVolumeWidth; x++ )

			{

				AddCubeToScene( mat, vertdataarray );

				mat = mat * Matrix4().translate( m_fScaleSpacing, 0, 0 );

			}

			mat = mat * Matrix4().translate( -((float)m_iSceneVolumeWidth) * m_fScaleSpacing, m_fScaleSpacing, 0 );

		}

		mat = mat * Matrix4().translate( 0, -((float)m_iSceneVolumeHeight) * m_fScaleSpacing, m_fScaleSpacing );

	}

	m_uiVertcount = vertdataarray.size()/5;

	

	glGenVertexArrays( 1, &m_unSceneVAO );

	glBindVertexArray( m_unSceneVAO );



	glGenBuffers( 1, &m_glSceneVertBuffer );

	glBindBuffer( GL_ARRAY_BUFFER, m_glSceneVertBuffer );

	glBufferData( GL_ARRAY_BUFFER, sizeof(float) * vertdataarray.size(), &vertdataarray[0], GL_STATIC_DRAW);



	GLsizei stride = sizeof(VertexDataScene);

	uintptr_t offset = 0;



	glEnableVertexAttribArray( 0 );

	glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, stride , (const void *)offset);



	offset += sizeof(Vector3);

	glEnableVertexAttribArray( 1 );

	glVertexAttribPointer( 1, 2, GL_FLOAT, GL_FALSE, stride, (const void *)offset);



	glBindVertexArray( 0 );

	glDisableVertexAttribArray(0);

	glDisableVertexAttribArray(1);



}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

void CMainApplication::AddCubeVertex( float fl0, float fl1, float fl2, float fl3, float fl4, std::vector &vertdata )

{

	vertdata.push_back( fl0 );

	vertdata.push_back( fl1 );

	vertdata.push_back( fl2 );

	vertdata.push_back( fl3 );

	vertdata.push_back( fl4 );

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

void CMainApplication::AddCubeToScene( Matrix4 mat, std::vector &vertdata )

{

	// Matrix4 mat( outermat.data() );



	Vector4 A = mat * Vector4( 0, 0, 0, 1 );

	Vector4 B = mat * Vector4( 1, 0, 0, 1 );

	Vector4 C = mat * Vector4( 1, 1, 0, 1 );

	Vector4 D = mat * Vector4( 0, 1, 0, 1 );

	Vector4 E = mat * Vector4( 0, 0, 1, 1 );

	Vector4 F = mat * Vector4( 1, 0, 1, 1 );

	Vector4 G = mat * Vector4( 1, 1, 1, 1 );

	Vector4 H = mat * Vector4( 0, 1, 1, 1 );



	// triangles instead of quads

	AddCubeVertex( E.x, E.y, E.z, 0, 1, vertdata ); //Front

	AddCubeVertex( F.x, F.y, F.z, 1, 1, vertdata );

	AddCubeVertex( G.x, G.y, G.z, 1, 0, vertdata );

	AddCubeVertex( G.x, G.y, G.z, 1, 0, vertdata );

	AddCubeVertex( H.x, H.y, H.z, 0, 0, vertdata );

	AddCubeVertex( E.x, E.y, E.z, 0, 1, vertdata );

					 

	AddCubeVertex( B.x, B.y, B.z, 0, 1, vertdata ); //Back

	AddCubeVertex( A.x, A.y, A.z, 1, 1, vertdata );

	AddCubeVertex( D.x, D.y, D.z, 1, 0, vertdata );

	AddCubeVertex( D.x, D.y, D.z, 1, 0, vertdata );

	AddCubeVertex( C.x, C.y, C.z, 0, 0, vertdata );

	AddCubeVertex( B.x, B.y, B.z, 0, 1, vertdata );

					

	AddCubeVertex( H.x, H.y, H.z, 0, 1, vertdata ); //Top

	AddCubeVertex( G.x, G.y, G.z, 1, 1, vertdata );

	AddCubeVertex( C.x, C.y, C.z, 1, 0, vertdata );

	AddCubeVertex( C.x, C.y, C.z, 1, 0, vertdata );

	AddCubeVertex( D.x, D.y, D.z, 0, 0, vertdata );

	AddCubeVertex( H.x, H.y, H.z, 0, 1, vertdata );

				

	AddCubeVertex( A.x, A.y, A.z, 0, 1, vertdata ); //Bottom

	AddCubeVertex( B.x, B.y, B.z, 1, 1, vertdata );

	AddCubeVertex( F.x, F.y, F.z, 1, 0, vertdata );

	AddCubeVertex( F.x, F.y, F.z, 1, 0, vertdata );

	AddCubeVertex( E.x, E.y, E.z, 0, 0, vertdata );

	AddCubeVertex( A.x, A.y, A.z, 0, 1, vertdata );

					

	AddCubeVertex( A.x, A.y, A.z, 0, 1, vertdata ); //Left

	AddCubeVertex( E.x, E.y, E.z, 1, 1, vertdata );

	AddCubeVertex( H.x, H.y, H.z, 1, 0, vertdata );

	AddCubeVertex( H.x, H.y, H.z, 1, 0, vertdata );

	AddCubeVertex( D.x, D.y, D.z, 0, 0, vertdata );

	AddCubeVertex( A.x, A.y, A.z, 0, 1, vertdata );



	AddCubeVertex( F.x, F.y, F.z, 0, 1, vertdata ); //Right

	AddCubeVertex( B.x, B.y, B.z, 1, 1, vertdata );

	AddCubeVertex( C.x, C.y, C.z, 1, 0, vertdata );

	AddCubeVertex( C.x, C.y, C.z, 1, 0, vertdata );

	AddCubeVertex( G.x, G.y, G.z, 0, 0, vertdata );

	AddCubeVertex( F.x, F.y, F.z, 0, 1, vertdata );

}





//-----------------------------------------------------------------------------

// Purpose: Draw all of the controllers as X/Y/Z lines

//-----------------------------------------------------------------------------

void CMainApplication::RenderControllerAxes()

{

	// Don't attempt to update controllers if input is not available

	if( !m_pHMD->IsInputAvailable() )

		return;



	std::vector vertdataarray;



	m_uiControllerVertcount = 0;

	m_iTrackedControllerCount = 0;



	for ( vr::TrackedDeviceIndex_t unTrackedDevice = vr::k_unTrackedDeviceIndex_Hmd + 1; unTrackedDevice < vr::k_unMaxTrackedDeviceCount; ++unTrackedDevice )

	{

		if ( !m_pHMD->IsTrackedDeviceConnected( unTrackedDevice ) )

			continue;



		if( m_pHMD->GetTrackedDeviceClass( unTrackedDevice ) != vr::TrackedDeviceClass_Controller )

			continue;



		m_iTrackedControllerCount += 1;



		if( !m_rTrackedDevicePose[ unTrackedDevice ].bPoseIsValid )

			continue;



		const Matrix4 & mat = m_rmat4DevicePose[unTrackedDevice];



		Vector4 center = mat * Vector4( 0, 0, 0, 1 );



		for ( int i = 0; i < 3; ++i )

		{

			Vector3 color( 0, 0, 0 );

			Vector4 point( 0, 0, 0, 1 );

			point[i] += 0.05f;  // offset in X, Y, Z

			color[i] = 1.0;  // R, G, B

			point = mat * point;

			vertdataarray.push_back( center.x );

			vertdataarray.push_back( center.y );

			vertdataarray.push_back( center.z );



			vertdataarray.push_back( color.x );

			vertdataarray.push_back( color.y );

			vertdataarray.push_back( color.z );

		

			vertdataarray.push_back( point.x );

			vertdataarray.push_back( point.y );

			vertdataarray.push_back( point.z );

		

			vertdataarray.push_back( color.x );

			vertdataarray.push_back( color.y );

			vertdataarray.push_back( color.z );

		

			m_uiControllerVertcount += 2;

		}



		Vector4 start = mat * Vector4( 0, 0, -0.02f, 1 );

		Vector4 end = mat * Vector4( 0, 0, -39.f, 1 );

		Vector3 color( .92f, .92f, .71f );



		vertdataarray.push_back( start.x );vertdataarray.push_back( start.y );vertdataarray.push_back( start.z );

		vertdataarray.push_back( color.x );vertdataarray.push_back( color.y );vertdataarray.push_back( color.z );



		vertdataarray.push_back( end.x );vertdataarray.push_back( end.y );vertdataarray.push_back( end.z );

		vertdataarray.push_back( color.x );vertdataarray.push_back( color.y );vertdataarray.push_back( color.z );

		m_uiControllerVertcount += 2;

	}



	// Setup the VAO the first time through.

	if ( m_unControllerVAO == 0 )

	{

		glGenVertexArrays( 1, &m_unControllerVAO );

		glBindVertexArray( m_unControllerVAO );



		glGenBuffers( 1, &m_glControllerVertBuffer );

		glBindBuffer( GL_ARRAY_BUFFER, m_glControllerVertBuffer );



		GLuint stride = 2 * 3 * sizeof( float );

		uintptr_t offset = 0;



		glEnableVertexAttribArray( 0 );

		glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, stride, (const void *)offset);



		offset += sizeof( Vector3 );

		glEnableVertexAttribArray( 1 );

		glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, stride, (const void *)offset);



		glBindVertexArray( 0 );

	}



	glBindBuffer( GL_ARRAY_BUFFER, m_glControllerVertBuffer );



	// set vertex data if we have some

	if( vertdataarray.size() > 0 )

	{

		//$ TODO: Use glBufferSubData for this...

		glBufferData( GL_ARRAY_BUFFER, sizeof(float) * vertdataarray.size(), &vertdataarray[0], GL_STREAM_DRAW );

	}

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

void CMainApplication::SetupCameras()

{

	m_mat4ProjectionLeft = GetHMDMatrixProjectionEye( vr::Eye_Left );

	m_mat4ProjectionRight = GetHMDMatrixProjectionEye( vr::Eye_Right );

	m_mat4eyePosLeft = GetHMDMatrixPoseEye( vr::Eye_Left );

	m_mat4eyePosRight = GetHMDMatrixPoseEye( vr::Eye_Right );

}





//-----------------------------------------------------------------------------

// Purpose: Creates a frame buffer. Returns true if the buffer was set up.

//          Returns false if the setup failed.

//-----------------------------------------------------------------------------

bool CMainApplication::CreateFrameBuffer( int nWidth, int nHeight, FramebufferDesc &framebufferDesc )

{

	glGenFramebuffers(1, &framebufferDesc.m_nRenderFramebufferId );

	glBindFramebuffer(GL_FRAMEBUFFER, framebufferDesc.m_nRenderFramebufferId);



	glGenRenderbuffers(1, &framebufferDesc.m_nDepthBufferId);

	glBindRenderbuffer(GL_RENDERBUFFER, framebufferDesc.m_nDepthBufferId);

	glRenderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_DEPTH_COMPONENT, nWidth, nHeight );

	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER,	framebufferDesc.m_nDepthBufferId );



	glGenTextures(1, &framebufferDesc.m_nRenderTextureId );

	glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, framebufferDesc.m_nRenderTextureId );

	glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, nWidth, nHeight, true);

	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, framebufferDesc.m_nRenderTextureId, 0);



	glGenFramebuffers(1, &framebufferDesc.m_nResolveFramebufferId );

	glBindFramebuffer(GL_FRAMEBUFFER, framebufferDesc.m_nResolveFramebufferId);



	glGenTextures(1, &framebufferDesc.m_nResolveTextureId );

	glBindTexture(GL_TEXTURE_2D, framebufferDesc.m_nResolveTextureId );

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);

	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, nWidth, nHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);

	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, framebufferDesc.m_nResolveTextureId, 0);



	// check FBO status

	GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);

	if (status != GL_FRAMEBUFFER_COMPLETE)

	{

		return false;

	}



	glBindFramebuffer( GL_FRAMEBUFFER, 0 );



	return true;

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

bool CMainApplication::SetupStereoRenderTargets()

{

	if ( !m_pHMD )

		return false;



	m_pHMD->GetRecommendedRenderTargetSize( &m_nRenderWidth, &m_nRenderHeight );



	CreateFrameBuffer( m_nRenderWidth, m_nRenderHeight, leftEyeDesc );

	CreateFrameBuffer( m_nRenderWidth, m_nRenderHeight, rightEyeDesc );

	

	return true;

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

void CMainApplication::SetupCompanionWindow()

{

	if ( !m_pHMD )

		return;



	std::vector vVerts;



	// left eye verts

	vVerts.push_back( VertexDataWindow( Vector2(-1, -1), Vector2(0, 1)) );

	vVerts.push_back( VertexDataWindow( Vector2(0, -1), Vector2(1, 1)) );

	vVerts.push_back( VertexDataWindow( Vector2(-1, 1), Vector2(0, 0)) );

	vVerts.push_back( VertexDataWindow( Vector2(0, 1), Vector2(1, 0)) );



	// right eye verts

	vVerts.push_back( VertexDataWindow( Vector2(0, -1), Vector2(0, 1)) );

	vVerts.push_back( VertexDataWindow( Vector2(1, -1), Vector2(1, 1)) );

	vVerts.push_back( VertexDataWindow( Vector2(0, 1), Vector2(0, 0)) );

	vVerts.push_back( VertexDataWindow( Vector2(1, 1), Vector2(1, 0)) );



	GLushort vIndices[] = { 0, 1, 3,   0, 3, 2,   4, 5, 7,   4, 7, 6};

	m_uiCompanionWindowIndexSize = _countof(vIndices);



	glGenVertexArrays( 1, &m_unCompanionWindowVAO );

	glBindVertexArray( m_unCompanionWindowVAO );



	glGenBuffers( 1, &m_glCompanionWindowIDVertBuffer );

	glBindBuffer( GL_ARRAY_BUFFER, m_glCompanionWindowIDVertBuffer );

	glBufferData( GL_ARRAY_BUFFER, vVerts.size()*sizeof(VertexDataWindow), &vVerts[0], GL_STATIC_DRAW );



	glGenBuffers( 1, &m_glCompanionWindowIDIndexBuffer );

	glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_glCompanionWindowIDIndexBuffer );

	glBufferData( GL_ELEMENT_ARRAY_BUFFER, m_uiCompanionWindowIndexSize*sizeof(GLushort), &vIndices[0], GL_STATIC_DRAW );



	glEnableVertexAttribArray( 0 );

	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(VertexDataWindow), (void *)offsetof( VertexDataWindow, position ) );



	glEnableVertexAttribArray( 1 );

	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(VertexDataWindow), (void *)offsetof( VertexDataWindow, texCoord ) );



	glBindVertexArray( 0 );



	glDisableVertexAttribArray(0);

	glDisableVertexAttribArray(1);



	glBindBuffer(GL_ARRAY_BUFFER, 0);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

void CMainApplication::RenderStereoTargets()

{

	glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );

	glEnable( GL_MULTISAMPLE );



	// Left Eye

	glBindFramebuffer( GL_FRAMEBUFFER, leftEyeDesc.m_nRenderFramebufferId );

 	glViewport(0, 0, m_nRenderWidth, m_nRenderHeight );

 	RenderScene( vr::Eye_Left );

 	glBindFramebuffer( GL_FRAMEBUFFER, 0 );

	

	glDisable( GL_MULTISAMPLE );

	 	

 	glBindFramebuffer(GL_READ_FRAMEBUFFER, leftEyeDesc.m_nRenderFramebufferId);

    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, leftEyeDesc.m_nResolveFramebufferId );



    glBlitFramebuffer( 0, 0, m_nRenderWidth, m_nRenderHeight, 0, 0, m_nRenderWidth, m_nRenderHeight, 

		GL_COLOR_BUFFER_BIT,

 		GL_LINEAR );



 	glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);

    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0 );	



	glEnable( GL_MULTISAMPLE );



	// Right Eye

	glBindFramebuffer( GL_FRAMEBUFFER, rightEyeDesc.m_nRenderFramebufferId );

 	glViewport(0, 0, m_nRenderWidth, m_nRenderHeight );

 	RenderScene( vr::Eye_Right );

 	glBindFramebuffer( GL_FRAMEBUFFER, 0 );

 	

	glDisable( GL_MULTISAMPLE );



 	glBindFramebuffer(GL_READ_FRAMEBUFFER, rightEyeDesc.m_nRenderFramebufferId );

    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, rightEyeDesc.m_nResolveFramebufferId );

	

    glBlitFramebuffer( 0, 0, m_nRenderWidth, m_nRenderHeight, 0, 0, m_nRenderWidth, m_nRenderHeight, 

		GL_COLOR_BUFFER_BIT,

 		GL_LINEAR  );



 	glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);

    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0 );

}





//-----------------------------------------------------------------------------

// Purpose: Renders a scene with respect to nEye.

//-----------------------------------------------------------------------------

void CMainApplication::RenderScene( vr::Hmd_Eye nEye )

{

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glEnable(GL_DEPTH_TEST);



	if( m_bShowCubes )

	{

		glUseProgram( m_unSceneProgramID );

		glUniformMatrix4fv( m_nSceneMatrixLocation, 1, GL_FALSE, GetCurrentViewProjectionMatrix( nEye ).get() );

		glBindVertexArray( m_unSceneVAO );

		glBindTexture( GL_TEXTURE_2D, m_iTexture );

		glDrawArrays( GL_TRIANGLES, 0, m_uiVertcount );

		glBindVertexArray( 0 );

	}



	bool bIsInputAvailable = m_pHMD->IsInputAvailable();



	if( bIsInputAvailable )

	{

		// draw the controller axis lines

		glUseProgram( m_unControllerTransformProgramID );

		glUniformMatrix4fv( m_nControllerMatrixLocation, 1, GL_FALSE, GetCurrentViewProjectionMatrix( nEye ).get() );

		glBindVertexArray( m_unControllerVAO );

		glDrawArrays( GL_LINES, 0, m_uiControllerVertcount );

		glBindVertexArray( 0 );

	}



	// ----- Render Model rendering -----

	glUseProgram( m_unRenderModelProgramID );



	for( uint32_t unTrackedDevice = 0; unTrackedDevice < vr::k_unMaxTrackedDeviceCount; unTrackedDevice++ )

	{

		if( !m_rTrackedDeviceToRenderModel[ unTrackedDevice ] || !m_rbShowTrackedDevice[ unTrackedDevice ] )

			continue;



		const vr::TrackedDevicePose_t & pose = m_rTrackedDevicePose[ unTrackedDevice ];

		if( !pose.bPoseIsValid )

			continue;



		if( !bIsInputAvailable && m_pHMD->GetTrackedDeviceClass( unTrackedDevice ) == vr::TrackedDeviceClass_Controller )

			continue;



		const Matrix4 & matDeviceToTracking = m_rmat4DevicePose[ unTrackedDevice ];

		Matrix4 matMVP = GetCurrentViewProjectionMatrix( nEye ) * matDeviceToTracking;

		glUniformMatrix4fv( m_nRenderModelMatrixLocation, 1, GL_FALSE, matMVP.get() );



		m_rTrackedDeviceToRenderModel[ unTrackedDevice ]->Draw();

	}



	glUseProgram( 0 );

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

void CMainApplication::RenderCompanionWindow()

{

	glDisable(GL_DEPTH_TEST);

	glViewport( 0, 0, m_nCompanionWindowWidth, m_nCompanionWindowHeight );



	glBindVertexArray( m_unCompanionWindowVAO );

	glUseProgram( m_unCompanionWindowProgramID );



	// render left eye (first half of index array )

	glBindTexture(GL_TEXTURE_2D, leftEyeDesc.m_nResolveTextureId );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );

	glDrawElements( GL_TRIANGLES, m_uiCompanionWindowIndexSize/2, GL_UNSIGNED_SHORT, 0 );



	// render right eye (second half of index array )

	glBindTexture(GL_TEXTURE_2D, rightEyeDesc.m_nResolveTextureId  );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );

	glDrawElements( GL_TRIANGLES, m_uiCompanionWindowIndexSize/2, GL_UNSIGNED_SHORT, (const void *)(uintptr_t)(m_uiCompanionWindowIndexSize) );



	glBindVertexArray( 0 );

	glUseProgram( 0 );

}





//-----------------------------------------------------------------------------

// Purpose: Gets a Matrix Projection Eye with respect to nEye.

//-----------------------------------------------------------------------------

Matrix4 CMainApplication::GetHMDMatrixProjectionEye( vr::Hmd_Eye nEye )

{

	if ( !m_pHMD )

		return Matrix4();



	vr::HmdMatrix44_t mat = m_pHMD->GetProjectionMatrix( nEye, m_fNearClip, m_fFarClip );



	return Matrix4(

		mat.m[0][0], mat.m[1][0], mat.m[2][0], mat.m[3][0],

		mat.m[0][1], mat.m[1][1], mat.m[2][1], mat.m[3][1], 

		mat.m[0][2], mat.m[1][2], mat.m[2][2], mat.m[3][2], 

		mat.m[0][3], mat.m[1][3], mat.m[2][3], mat.m[3][3]

	);

}





//-----------------------------------------------------------------------------

// Purpose: Gets an HMDMatrixPoseEye with respect to nEye.

//-----------------------------------------------------------------------------

Matrix4 CMainApplication::GetHMDMatrixPoseEye( vr::Hmd_Eye nEye )

{

	if ( !m_pHMD )

		return Matrix4();



	vr::HmdMatrix34_t matEyeRight = m_pHMD->GetEyeToHeadTransform( nEye );

	Matrix4 matrixObj(

		matEyeRight.m[0][0], matEyeRight.m[1][0], matEyeRight.m[2][0], 0.0, 

		matEyeRight.m[0][1], matEyeRight.m[1][1], matEyeRight.m[2][1], 0.0,

		matEyeRight.m[0][2], matEyeRight.m[1][2], matEyeRight.m[2][2], 0.0,

		matEyeRight.m[0][3], matEyeRight.m[1][3], matEyeRight.m[2][3], 1.0f

		);



	return matrixObj.invert();

}





//-----------------------------------------------------------------------------

// Purpose: Gets a Current View Projection Matrix with respect to nEye,

//          which may be an Eye_Left or an Eye_Right.

//-----------------------------------------------------------------------------

Matrix4 CMainApplication::GetCurrentViewProjectionMatrix( vr::Hmd_Eye nEye )

{

	Matrix4 matMVP;

	if( nEye == vr::Eye_Left )

	{

		matMVP = m_mat4ProjectionLeft * m_mat4eyePosLeft * m_mat4HMDPose;

	}

	else if( nEye == vr::Eye_Right )

	{

		matMVP = m_mat4ProjectionRight * m_mat4eyePosRight *  m_mat4HMDPose;

	}



	return matMVP;

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

void CMainApplication::UpdateHMDMatrixPose()

{

	if ( !m_pHMD )

		return;



	vr::VRCompositor()->WaitGetPoses(m_rTrackedDevicePose, vr::k_unMaxTrackedDeviceCount, NULL, 0 );



	m_iValidPoseCount = 0;

	m_strPoseClasses = "";

	for ( int nDevice = 0; nDevice < vr::k_unMaxTrackedDeviceCount; ++nDevice )

	{

		if ( m_rTrackedDevicePose[nDevice].bPoseIsValid )

		{

			m_iValidPoseCount++;

			m_rmat4DevicePose[nDevice] = ConvertSteamVRMatrixToMatrix4( m_rTrackedDevicePose[nDevice].mDeviceToAbsoluteTracking );

			if (m_rDevClassChar[nDevice]==0)

			{

				switch (m_pHMD->GetTrackedDeviceClass(nDevice))

				{

				case vr::TrackedDeviceClass_Controller:        m_rDevClassChar[nDevice] = 'C'; break;

				case vr::TrackedDeviceClass_HMD:               m_rDevClassChar[nDevice] = 'H'; break;

				case vr::TrackedDeviceClass_Invalid:           m_rDevClassChar[nDevice] = 'I'; break;

				case vr::TrackedDeviceClass_GenericTracker:    m_rDevClassChar[nDevice] = 'G'; break;

				case vr::TrackedDeviceClass_TrackingReference: m_rDevClassChar[nDevice] = 'T'; break;

				default:                                       m_rDevClassChar[nDevice] = '?'; break;

				}

			}

			m_strPoseClasses += m_rDevClassChar[nDevice];

		}

	}



	if ( m_rTrackedDevicePose[vr::k_unTrackedDeviceIndex_Hmd].bPoseIsValid )

	{

		m_mat4HMDPose = m_rmat4DevicePose[vr::k_unTrackedDeviceIndex_Hmd];

		m_mat4HMDPose.invert();

	}

}





//-----------------------------------------------------------------------------

// Purpose: Finds a render model we've already loaded or loads a new one

//-----------------------------------------------------------------------------

CGLRenderModel *CMainApplication::FindOrLoadRenderModel( const char *pchRenderModelName )

{

	CGLRenderModel *pRenderModel = NULL;

	for( std::vector< CGLRenderModel * >::iterator i = m_vecRenderModels.begin(); i != m_vecRenderModels.end(); i++ )

	{

		if( !stricmp( (*i)->GetName().c_str(), pchRenderModelName ) )

		{

			pRenderModel = *i;

			break;

		}

	}



	// load the model if we didn't find one

	if( !pRenderModel )

	{

		vr::RenderModel_t *pModel;

		vr::EVRRenderModelError error;

		while ( 1 )

		{

			error = vr::VRRenderModels()->LoadRenderModel_Async( pchRenderModelName, &pModel );

			if ( error != vr::VRRenderModelError_Loading )

				break;



			ThreadSleep( 1 );

		}



		if ( error != vr::VRRenderModelError_None )

		{

			dprintf( "Unable to load render model %s - %s\n", pchRenderModelName, vr::VRRenderModels()->GetRenderModelErrorNameFromEnum( error ) );

			return NULL; // move on to the next tracked device

		}



		vr::RenderModel_TextureMap_t *pTexture;

		while ( 1 )

		{

			error = vr::VRRenderModels()->LoadTexture_Async( pModel->diffuseTextureId, &pTexture );

			if ( error != vr::VRRenderModelError_Loading )

				break;



			ThreadSleep( 1 );

		}



		if ( error != vr::VRRenderModelError_None )

		{

			dprintf( "Unable to load render texture id:%d for render model %s\n", pModel->diffuseTextureId, pchRenderModelName );

			vr::VRRenderModels()->FreeRenderModel( pModel );

			return NULL; // move on to the next tracked device

		}



		pRenderModel = new CGLRenderModel( pchRenderModelName );

		if ( !pRenderModel->BInit( *pModel, *pTexture ) )

		{

			dprintf( "Unable to create GL model from render model %s\n", pchRenderModelName );

			delete pRenderModel;

			pRenderModel = NULL;

		}

		else

		{

			m_vecRenderModels.push_back( pRenderModel );

		}

		vr::VRRenderModels()->FreeRenderModel( pModel );

		vr::VRRenderModels()->FreeTexture( pTexture );

	}

	return pRenderModel;

}





//-----------------------------------------------------------------------------

// Purpose: Create/destroy GL a Render Model for a single tracked device

//-----------------------------------------------------------------------------

void CMainApplication::SetupRenderModelForTrackedDevice( vr::TrackedDeviceIndex_t unTrackedDeviceIndex )

{

	if( unTrackedDeviceIndex >= vr::k_unMaxTrackedDeviceCount )

		return;



	// try to find a model we've already set up

	std::string sRenderModelName = GetTrackedDeviceString( m_pHMD, unTrackedDeviceIndex, vr::Prop_RenderModelName_String );

	CGLRenderModel *pRenderModel = FindOrLoadRenderModel( sRenderModelName.c_str() );

	if( !pRenderModel )

	{

		std::string sTrackingSystemName = GetTrackedDeviceString( m_pHMD, unTrackedDeviceIndex, vr::Prop_TrackingSystemName_String );

		dprintf( "Unable to load render model for tracked device %d (%s.%s)", unTrackedDeviceIndex, sTrackingSystemName.c_str(), sRenderModelName.c_str() );

	}

	else

	{

		m_rTrackedDeviceToRenderModel[ unTrackedDeviceIndex ] = pRenderModel;

		m_rbShowTrackedDevice[ unTrackedDeviceIndex ] = true;

	}

}





//-----------------------------------------------------------------------------

// Purpose: Create/destroy GL Render Models

//-----------------------------------------------------------------------------

void CMainApplication::SetupRenderModels()

{

	memset( m_rTrackedDeviceToRenderModel, 0, sizeof( m_rTrackedDeviceToRenderModel ) );



	if( !m_pHMD )

		return;



	for( uint32_t unTrackedDevice = vr::k_unTrackedDeviceIndex_Hmd + 1; unTrackedDevice < vr::k_unMaxTrackedDeviceCount; unTrackedDevice++ )

	{

		if( !m_pHMD->IsTrackedDeviceConnected( unTrackedDevice ) )

			continue;



		SetupRenderModelForTrackedDevice( unTrackedDevice );

	}



}





//-----------------------------------------------------------------------------

// Purpose: Converts a SteamVR matrix to our local matrix class

//-----------------------------------------------------------------------------

Matrix4 CMainApplication::ConvertSteamVRMatrixToMatrix4( const vr::HmdMatrix34_t &matPose )

{

	Matrix4 matrixObj(

		matPose.m[0][0], matPose.m[1][0], matPose.m[2][0], 0.0,

		matPose.m[0][1], matPose.m[1][1], matPose.m[2][1], 0.0,

		matPose.m[0][2], matPose.m[1][2], matPose.m[2][2], 0.0,

		matPose.m[0][3], matPose.m[1][3], matPose.m[2][3], 1.0f

		);

	return matrixObj;

}





//-----------------------------------------------------------------------------

// Purpose: Create/destroy GL Render Models

//-----------------------------------------------------------------------------

CGLRenderModel::CGLRenderModel( const std::string & sRenderModelName )

	: m_sModelName( sRenderModelName )

{

	m_glIndexBuffer = 0;

	m_glVertArray = 0;

	m_glVertBuffer = 0;

	m_glTexture = 0;

}





CGLRenderModel::~CGLRenderModel()

{

	Cleanup();

}





//-----------------------------------------------------------------------------

// Purpose: Allocates and populates the GL resources for a render model

//-----------------------------------------------------------------------------

bool CGLRenderModel::BInit( const vr::RenderModel_t & vrModel, const vr::RenderModel_TextureMap_t & vrDiffuseTexture )

{

	// create and bind a VAO to hold state for this model

	glGenVertexArrays( 1, &m_glVertArray );

	glBindVertexArray( m_glVertArray );



	// Populate a vertex buffer

	glGenBuffers( 1, &m_glVertBuffer );

	glBindBuffer( GL_ARRAY_BUFFER, m_glVertBuffer );

	glBufferData( GL_ARRAY_BUFFER, sizeof( vr::RenderModel_Vertex_t ) * vrModel.unVertexCount, vrModel.rVertexData, GL_STATIC_DRAW );



	// Identify the components in the vertex buffer

	glEnableVertexAttribArray( 0 );

	glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, sizeof( vr::RenderModel_Vertex_t ), (void *)offsetof( vr::RenderModel_Vertex_t, vPosition ) );

	glEnableVertexAttribArray( 1 );

	glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, sizeof( vr::RenderModel_Vertex_t ), (void *)offsetof( vr::RenderModel_Vertex_t, vNormal ) );

	glEnableVertexAttribArray( 2 );

	glVertexAttribPointer( 2, 2, GL_FLOAT, GL_FALSE, sizeof( vr::RenderModel_Vertex_t ), (void *)offsetof( vr::RenderModel_Vertex_t, rfTextureCoord ) );



	// Create and populate the index buffer

	glGenBuffers( 1, &m_glIndexBuffer );

	glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, m_glIndexBuffer );

	glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof( uint16_t ) * vrModel.unTriangleCount * 3, vrModel.rIndexData, GL_STATIC_DRAW );



	glBindVertexArray( 0 );



	// create and populate the texture

	glGenTextures(1, &m_glTexture );

	glBindTexture( GL_TEXTURE_2D, m_glTexture );



	glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, vrDiffuseTexture.unWidth, vrDiffuseTexture.unHeight,

		0, GL_RGBA, GL_UNSIGNED_BYTE, vrDiffuseTexture.rubTextureMapData );



	// If this renders black ask McJohn what's wrong.

	glGenerateMipmap(GL_TEXTURE_2D);



	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );

	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );



	GLfloat fLargest;

	glGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fLargest );

	glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest );



	glBindTexture( GL_TEXTURE_2D, 0 );



	m_unVertexCount = vrModel.unTriangleCount * 3;



	return true;

}





//-----------------------------------------------------------------------------

// Purpose: Frees the GL resources for a render model

//-----------------------------------------------------------------------------

void CGLRenderModel::Cleanup()

{

	if( m_glVertBuffer )

	{

		glDeleteBuffers(1, &m_glIndexBuffer);

		glDeleteVertexArrays( 1, &m_glVertArray );

		glDeleteBuffers(1, &m_glVertBuffer);

		m_glIndexBuffer = 0;

		m_glVertArray = 0;

		m_glVertBuffer = 0;

	}

}





//-----------------------------------------------------------------------------

// Purpose: Draws the render model

//-----------------------------------------------------------------------------

void CGLRenderModel::Draw()

{

	glBindVertexArray( m_glVertArray );



	glActiveTexture( GL_TEXTURE0 );

	glBindTexture( GL_TEXTURE_2D, m_glTexture );



	glDrawElements( GL_TRIANGLES, m_unVertexCount, GL_UNSIGNED_SHORT, 0 );



	glBindVertexArray( 0 );

}





//-----------------------------------------------------------------------------

// Purpose:

//-----------------------------------------------------------------------------

int main(int argc, char *argv[])

{

	CMainApplication *pMainApplication = new CMainApplication( argc, argv );



	if (!pMainApplication->BInit())

	{

		pMainApplication->Shutdown();

		return 1;

	}



	pMainApplication->RunMainLoop();



	pMainApplication->Shutdown();



	return 0;

}