/// @copydoc Entity::Attach()
void Camera::Attach()
{
Base::Attach();
// Update the scene view associated with this camera.
if( IsValid( m_sceneViewId ) )
{
World* pWorld = GetWorld();
HELIUM_ASSERT( pWorld );
GraphicsScene* pScene = pWorld->GetGraphicsScene();
if( pScene )
{
GraphicsSceneView* pSceneView = pScene->GetSceneView( m_sceneViewId );
if( pSceneView )
{
Simd::Matrix44 rotationMatrix( Simd::Matrix44::INIT_ROTATION, GetRotation() );
pSceneView->SetView(
GetPosition(),
Vector4ToVector3( rotationMatrix.GetRow( 2 ) ),
Vector4ToVector3( rotationMatrix.GetRow( 1 ) ) );
pSceneView->SetHorizontalFov( m_fov );
}
}
}
}
void Viewport::OnResize()
{
const uint32_t width = (m_Size.x > 0) ? m_Size.x : 64;
const uint32_t height = (m_Size.y > 0) ? m_Size.y : 64;
const float32_t aspectRatio =
static_cast< float32_t >( width ) / static_cast< float32_t >( height );
if (m_World)
{
Renderer* pRenderer = Renderer::GetStaticInstance();
Renderer::ContextInitParameters ctxParams;
ctxParams.pWindow = m_Window;
ctxParams.displayWidth = width;
ctxParams.displayHeight = height;
ctxParams.bFullscreen = false;
ctxParams.bVsync = false;
RRenderContextPtr renderCtx = pRenderer->CreateSubContext( ctxParams );
GraphicsScene* pGraphicsScene = GetGraphicsScene();
GraphicsSceneView* pSceneView = pGraphicsScene->GetSceneView( m_SceneViewId );
pSceneView->SetRenderContext( renderCtx );
pSceneView->SetDepthStencilSurface( RenderResourceManager::GetStaticInstance().GetDepthStencilSurface() );
pSceneView->SetAspectRatio( aspectRatio );
pSceneView->SetViewport( 0, 0, width, height );
pSceneView->SetClearColor( Helium::Color( 0x00505050 ) );
}
}
void GraphicsManagerComponent::Initialize( const GraphicsManagerComponentDefinition &definition)
{
m_spGraphicsScene = Reflect::AssertCast<GraphicsScene>(GraphicsScene::CreateObject());
HELIUM_ASSERT( m_spGraphicsScene );
if( !m_spGraphicsScene )
{
HELIUM_TRACE( TraceLevels::Error, TXT( "World::Initialize(): Failed to create a primary graphics scene.\n" ) );
return;
}
RenderResourceManager &rRenderResourceManager = RenderResourceManager::GetStaticInstance();
Renderer *pRenderer = Renderer::GetStaticInstance();
RRenderContext *rRenderContext = pRenderer->GetMainContext();
HELIUM_ASSERT( rRenderContext );
uint32_t mainSceneViewId = m_spGraphicsScene->AllocateSceneView();
if( IsValid( mainSceneViewId ) )
{
float32_t aspectRatio =
static_cast< float32_t >( 800 ) / static_cast< float32_t >( 600 );
RSurface* pDepthStencilSurface = rRenderResourceManager.GetDepthStencilSurface();
HELIUM_ASSERT( pDepthStencilSurface );
GraphicsSceneView* pMainSceneView = m_spGraphicsScene->GetSceneView( mainSceneViewId );
HELIUM_ASSERT( pMainSceneView );
pMainSceneView->SetRenderContext( rRenderContext );
pMainSceneView->SetDepthStencilSurface( pDepthStencilSurface );
pMainSceneView->SetAspectRatio( aspectRatio );
pMainSceneView->SetViewport( 0, 0, 800, 600 );
pMainSceneView->SetClearColor( Color( 0x00202020 ) );
}
}
void Viewport::Draw()
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("") );
uint64_t start = Helium::TimerGetClock();
if (!m_World)
{
return;
}
Camera& camera = m_Cameras[m_CameraMode];
GraphicsScene* pGraphicsScene = GetGraphicsScene();
GraphicsSceneView* pSceneView = pGraphicsScene->GetSceneView( m_SceneViewId );
BufferedDrawer* pDrawer = pGraphicsScene->GetSceneViewBufferedDrawer( m_SceneViewId );
DrawArgs args;
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Setup Viewport and Projection") );
Vector3 pos;
camera.GetPosition( pos );
const Matrix4& invView = camera.GetInverseView();
pSceneView->SetView(
Simd::Vector3( &pos.x ),
-Simd::Vector3( &invView.z.x ),
Simd::Vector3( &invView.y.x ) );
pSceneView->SetHorizontalFov( Camera::FieldOfView * static_cast< float32_t >(HELIUM_RAD_TO_DEG) );
}
if (m_GridVisible)
{
m_GlobalPrimitives[GlobalPrimitives::StandardGrid]->Draw( pDrawer, &args );
}
#ifdef VIEWPORT_REFACTOR
// this seems like a bad place to do this
if (m_Tool)
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Tool Evaluate") );
m_Tool->Evaluate();
}
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Clear and Reset Scene") );
device->BeginScene();
device->SetRenderTarget( 0, m_DeviceManager.GetBackBuffer() );
device->SetDepthStencilSurface( m_DeviceManager.GetDepthBuffer() );
device->Clear(NULL, NULL, D3DCLEAR_TARGET | D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(255, 80, 80, 80), 1.0f, 0);
device->SetTransform(D3DTS_WORLD, (D3DMATRIX*)&Matrix4::Identity);
m_ResourceTracker->ResetState();
}
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Setup Viewport and Projection") );
device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)&m_Cameras[m_CameraMode].SetProjection(m_Size.x, m_Size.y));
device->SetTransform(D3DTS_VIEW, (D3DMATRIX*)&m_Cameras[m_CameraMode].GetViewport());
}
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Setup RenderState (culling, lighting, and fill") );
device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
if (m_Cameras[m_CameraMode].IsBackFaceCulling())
{
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
}
else
{
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
}
device->SetRenderState(D3DRS_LIGHTING, TRUE);
device->SetRenderState(D3DRS_COLORVERTEX, FALSE);
device->SetRenderState(D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL);
device->SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
device->SetRenderState(D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);
device->SetRenderState(D3DRS_ZENABLE, TRUE);
device->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE);
device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
device->SetPixelShader( NULL );
device->SetVertexShader( NULL );
D3DLIGHT9 light;
ZeroMemory(&light, sizeof(light));
D3DCOLORVALUE ambient;
D3DCOLORVALUE diffuse;
D3DCOLORVALUE specular;
if ( m_Cameras[m_CameraMode].GetShadingMode() == ShadingMode::Wireframe )
{
ambient = SceneGraph::Color::DIMGRAY;
diffuse = SceneGraph::Color::BLACK;
specular = SceneGraph::Color::BLACK;
}
else
{
ambient = SceneGraph::Color::DIMGRAY;
diffuse = SceneGraph::Color::SILVER;
specular = SceneGraph::Color::SILVER;
}
Vector3 dir;
m_Cameras[m_CameraMode].GetDirection(dir);
// setup light
light.Type = D3DLIGHT_DIRECTIONAL;
light.Ambient = ambient;
light.Diffuse = diffuse;
light.Specular = specular;
// set light into runtime
light.Direction = *(D3DVECTOR*)&dir;
device->SetLight(0, &light);
device->LightEnable(0, true);
// light from the back
dir *= -1.0f;
// set light into runtime
light.Direction = *(D3DVECTOR*)&dir;
device->SetLight(1, &light);
device->LightEnable(1, true);
}
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("PreRender") );
device->SetTransform(D3DTS_WORLD, (D3DMATRIX*)&Matrix4::Identity);
if (m_GridVisible)
{
m_GlobalPrimitives[GlobalPrimitives::StandardGrid]->Draw( &args );
}
}
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Render") );
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Render Setup") );
m_RenderVisitor.Reset( &args, this );
}
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Render Walk") );
m_Render.Raise( &m_RenderVisitor );
}
if (m_Tool)
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Render Tool") );
m_Tool->Draw( &args );
}
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Render Draw") );
m_RenderVisitor.Draw();
}
args.m_EntryCount = m_RenderVisitor.GetSize();
}
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("PostRender") );
device->SetTransform(D3DTS_WORLD, (D3DMATRIX*)&Matrix4::Identity);
device->Clear(NULL, NULL, D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
if (m_AxesVisible)
{
static_cast<SceneGraph::PrimitiveAxes*>(m_GlobalPrimitives[GlobalPrimitives::ViewportAxes])->DrawViewport( &args, &m_Cameras[m_CameraMode] );
}
if (m_Tool)
{
m_Tool->Draw( &args );
}
if ( m_Focused )
{
unsigned w = 3;
unsigned x = m_Size.x;
unsigned y = m_Size.y;
uint32_t color = D3DCOLOR_ARGB(255, 200, 200, 200);
std::vector< TransformedColored > vertices;
// <--
// | \ ^
// v \ |
// -->
// top
vertices.push_back(TransformedColored ((float)0, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)w, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)w, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)0, 1.0f, color));
// bottom
vertices.push_back(TransformedColored ((float)0, (float)y-w, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)y-w, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)y-w, 1.0f, color));
// left
vertices.push_back(TransformedColored ((float)0, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)w, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)w, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)0, 1.0f, color));
// right
vertices.push_back(TransformedColored ((float)x-w, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)x-w, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)x-w, (float)0, 1.0f, color));
device->SetRenderState(D3DRS_ZENABLE, FALSE);
device->SetFVF(ElementFormats[ElementTypes::TransformedColored]);
device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, &vertices.front(), sizeof(TransformedColored));
device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, &(vertices[5]), sizeof(TransformedColored));
device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, &(vertices[10]), sizeof(TransformedColored));
device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, &(vertices[15]), sizeof(TransformedColored));
device->SetRenderState(D3DRS_ZENABLE, TRUE);
m_ResourceTracker->ResetState();
}
if (m_DragMode == DragModes::Select)
{
m_SelectionFrame->Draw( &args );
}
}
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Process Statistics") );
m_Statistics->m_FrameNumber++;
m_Statistics->m_FrameCount++;
m_Statistics->m_RenderTime += Helium::CyclesToMillis( Helium::TimerGetClock() - start );
m_Statistics->m_RenderWalkTime += args.m_WalkTime;
m_Statistics->m_RenderSortTime += args.m_SortTime;
m_Statistics->m_RenderCompareTime += args.m_CompareTime;
m_Statistics->m_RenderDrawTime += args.m_DrawTime;
m_Statistics->m_EntryCount += args.m_EntryCount;
m_Statistics->m_TriangleCount += args.m_TriangleCount;
m_Statistics->m_LineCount += args.m_LineCount;
m_Statistics->Update();
if (m_StatisticsVisible)
{
m_Statistics->Draw(&args);
}
}
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("End Scene") );
device->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
device->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );
device->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
device->EndScene();
}
{
SCENE_GRAPH_RENDER_SCOPE_TIMER( ("Display") );
if ( m_DeviceManager.Display( m_Window ) == D3DERR_DEVICELOST )
{
m_DeviceManager.SetDeviceLost();
}
}
#endif
}
int APIENTRY _tWinMain( HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR /*lpCmdLine*/, int nCmdShow )
{
ForceLoadComponentsDll();
#if HELIUM_TOOLS
ForceLoadEditorSupportDll();
#endif
HELIUM_TRACE_SET_LEVEL( TraceLevels::Debug );
Timer::StaticInitialize();
#if !HELIUM_RELEASE && !HELIUM_PROFILE
Helium::InitializeSymbols();
#endif
AsyncLoader::GetStaticInstance().Initialize();
FilePath baseDirectory;
if ( !FileLocations::GetBaseDirectory( baseDirectory ) )
{
HELIUM_TRACE( TraceLevels::Error, TXT( "Could not get base directory." ) );
return -1;
}
HELIUM_VERIFY( CacheManager::InitializeStaticInstance( baseDirectory ) );
Helium::Bullet::Initialize();
int resultCode = -1;
{
Reflect::Initialize();
Helium::Components::Initialize();
Helium::TaskScheduler::CalculateSchedule();
#if HELIUM_TOOLS
#endif
InitEngineJobsDefaultHeap();
InitGraphicsJobsDefaultHeap();
InitTestJobsDefaultHeap();
#if HELIUM_TOOLS
//HELIUM_VERIFY( LooseAssetLoader::InitializeStaticInstance() );
HELIUM_VERIFY( LooseAssetLoader::InitializeStaticInstance() );
AssetPreprocessor* pAssetPreprocessor = AssetPreprocessor::CreateStaticInstance();
HELIUM_ASSERT( pAssetPreprocessor );
PlatformPreprocessor* pPlatformPreprocessor = new PcPreprocessor;
HELIUM_ASSERT( pPlatformPreprocessor );
pAssetPreprocessor->SetPlatformPreprocessor( Cache::PLATFORM_PC, pPlatformPreprocessor );
#else
HELIUM_VERIFY( CacheAssetLoader::InitializeStaticInstance() );
#endif
#if !GTEST
AssetLoader* gAssetLoader = NULL;
#endif
gAssetLoader = AssetLoader::GetStaticInstance();
HELIUM_ASSERT( gAssetLoader );
Config& rConfig = Config::GetStaticInstance();
rConfig.BeginLoad();
while( !rConfig.TryFinishLoad() )
{
gAssetLoader->Tick();
}
#if HELIUM_TOOLS
ConfigPc::SaveUserConfig();
#endif
uint32_t displayWidth;
uint32_t displayHeight;
//bool bFullscreen;
bool bVsync;
{
StrongPtr< GraphicsConfig > spGraphicsConfig(
rConfig.GetConfigObject< GraphicsConfig >( Name( TXT( "GraphicsConfig" ) ) ) );
HELIUM_ASSERT( spGraphicsConfig );
displayWidth = spGraphicsConfig->GetWidth();
displayHeight = spGraphicsConfig->GetHeight();
//bFullscreen = spGraphicsConfig->GetFullscreen();
bVsync = spGraphicsConfig->GetVsync();
}
WNDCLASSEXW windowClass;
windowClass.cbSize = sizeof( windowClass );
windowClass.style = 0;
windowClass.lpfnWndProc = WindowProc;
windowClass.cbClsExtra = 0;
windowClass.cbWndExtra = 0;
windowClass.hInstance = hInstance;
windowClass.hIcon = NULL;
windowClass.hCursor = NULL;
windowClass.hbrBackground = NULL;
windowClass.lpszMenuName = NULL;
windowClass.lpszClassName = L"HeliumTestAppClass";
windowClass.hIconSm = NULL;
HELIUM_VERIFY( RegisterClassEx( &windowClass ) );
WindowData windowData;
windowData.hMainWnd = NULL;
windowData.hSubWnd = NULL;
windowData.bProcessMessages = true;
windowData.bShutdownRendering = false;
windowData.resultCode = 0;
DWORD dwStyle = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU;
RECT windowRect;
windowRect.left = 0;
windowRect.top = 0;
windowRect.right = static_cast< LONG >( displayWidth );
windowRect.bottom = static_cast< LONG >( displayHeight );
HELIUM_VERIFY( AdjustWindowRect( &windowRect, dwStyle, FALSE ) );
HWND hMainWnd = ::CreateWindowW(
L"HeliumTestAppClass",
L"Helium TestApp",
dwStyle,
CW_USEDEFAULT,
CW_USEDEFAULT,
windowRect.right - windowRect.left,
windowRect.bottom - windowRect.top,
NULL,
NULL,
hInstance,
NULL );
HELIUM_ASSERT( hMainWnd );
windowRect.left = 0;
windowRect.top = 0;
windowRect.right = static_cast< LONG >( displayWidth );
windowRect.bottom = static_cast< LONG >( displayHeight );
HELIUM_VERIFY( AdjustWindowRect( &windowRect, dwStyle, FALSE ) );
#if MULTI_WINDOW
HWND hSubWnd = ::CreateWindowW(
L"HeliumTestAppClass",
L"Helium TestApp (second view)",
dwStyle,
CW_USEDEFAULT,
CW_USEDEFAULT,
windowRect.right - windowRect.left,
windowRect.bottom - windowRect.top,
NULL,
NULL,
hInstance,
NULL );
HELIUM_ASSERT( hSubWnd );
#endif
windowData.hMainWnd = hMainWnd;
SetWindowLongPtr( hMainWnd, GWLP_USERDATA, reinterpret_cast< LONG_PTR >( &windowData ) );
ShowWindow( hMainWnd, nCmdShow );
UpdateWindow( hMainWnd );
#if MULTI_WINDOW
windowData.hSubWnd = hSubWnd;
SetWindowLongPtr( hSubWnd, GWLP_USERDATA, reinterpret_cast< LONG_PTR >( &windowData ) );
ShowWindow( hSubWnd, nCmdShow );
UpdateWindow( hSubWnd );
#endif
HELIUM_VERIFY( D3D9Renderer::CreateStaticInstance() );
Renderer* pRenderer = Renderer::GetStaticInstance();
HELIUM_ASSERT( pRenderer );
pRenderer->Initialize();
Renderer::ContextInitParameters contextInitParams;
contextInitParams.pWindow = hMainWnd;
contextInitParams.displayWidth = displayWidth;
contextInitParams.displayHeight = displayHeight;
contextInitParams.bVsync = bVsync;
HELIUM_VERIFY( pRenderer->CreateMainContext( contextInitParams ) );
#if MULTI_WINDOW
contextInitParams.pWindow = hSubWnd;
RRenderContextPtr spSubRenderContext = pRenderer->CreateSubContext( contextInitParams );
HELIUM_ASSERT( spSubRenderContext );
#endif
Input::Initialize(&hMainWnd, false);
{
AssetPath prePassShaderPath;
HELIUM_VERIFY( prePassShaderPath.Set(
HELIUM_PACKAGE_PATH_CHAR_STRING TXT( "Shaders" ) HELIUM_OBJECT_PATH_CHAR_STRING TXT( "PrePass.hlsl" ) ) );
AssetPtr spPrePassShader;
HELIUM_VERIFY( AssetLoader::GetStaticInstance()->LoadObject( prePassShaderPath, spPrePassShader ) );
HELIUM_ASSERT( spPrePassShader.Get() );
}
RenderResourceManager& rRenderResourceManager = RenderResourceManager::GetStaticInstance();
rRenderResourceManager.Initialize();
rRenderResourceManager.UpdateMaxViewportSize( displayWidth, displayHeight );
//// Create a scene definition
SceneDefinitionPtr spSceneDefinition;
gAssetLoader->LoadObject( AssetPath( TXT( "/ExampleGames/Empty/Scenes/TestScene:SceneDefinition" ) ), spSceneDefinition );
EntityDefinitionPtr spEntityDefinition;
gAssetLoader->LoadObject( AssetPath( TXT( "/ExampleGames/Empty/Scenes/TestScene:TestBull_Entity" ) ), spEntityDefinition );
DynamicDrawer& rDynamicDrawer = DynamicDrawer::GetStaticInstance();
HELIUM_VERIFY( rDynamicDrawer.Initialize() );
RRenderContextPtr spMainRenderContext = pRenderer->GetMainContext();
HELIUM_ASSERT( spMainRenderContext );
WorldManager& rWorldManager = WorldManager::GetStaticInstance();
HELIUM_VERIFY( rWorldManager.Initialize() );
// Create a world
WorldPtr spWorld( rWorldManager.CreateWorld( spSceneDefinition ) );
HELIUM_ASSERT( spWorld );
HELIUM_TRACE( TraceLevels::Info, TXT( "Created world \"%s\".\n" ), *spSceneDefinition->GetPath().ToString() );
//Slice *pRootSlice = spWorld->GetRootSlice();
//Entity *pEntity = pRootSlice->CreateEntity(spEntityDefinition);
GraphicsScene* pGraphicsScene = spWorld->GetComponents().GetFirst<GraphicsManagerComponent>()->GetGraphicsScene();
HELIUM_ASSERT( pGraphicsScene );
GraphicsSceneView* pMainSceneView = NULL;
if( pGraphicsScene )
{
uint32_t mainSceneViewId = pGraphicsScene->AllocateSceneView();
if( IsValid( mainSceneViewId ) )
{
float32_t aspectRatio =
static_cast< float32_t >( displayWidth ) / static_cast< float32_t >( displayHeight );
RSurface* pDepthStencilSurface = rRenderResourceManager.GetDepthStencilSurface();
HELIUM_ASSERT( pDepthStencilSurface );
pMainSceneView = pGraphicsScene->GetSceneView( mainSceneViewId );
HELIUM_ASSERT( pMainSceneView );
pMainSceneView->SetRenderContext( spMainRenderContext );
pMainSceneView->SetDepthStencilSurface( pDepthStencilSurface );
pMainSceneView->SetAspectRatio( aspectRatio );
pMainSceneView->SetViewport( 0, 0, displayWidth, displayHeight );
pMainSceneView->SetClearColor( Color( 0x00202020 ) );
//spMainCamera->SetSceneViewId( mainSceneViewId );
#if MULTI_WINDOW
uint32_t subSceneViewId = pGraphicsScene->AllocateSceneView();
if( IsValid( subSceneViewId ) )
{
GraphicsSceneView* pSubSceneView = pGraphicsScene->GetSceneView( subSceneViewId );
HELIUM_ASSERT( pSubSceneView );
pSubSceneView->SetRenderContext( spSubRenderContext );
pSubSceneView->SetDepthStencilSurface( pDepthStencilSurface );
pSubSceneView->SetAspectRatio( aspectRatio );
pSubSceneView->SetViewport( 0, 0, displayWidth, displayHeight );
pSubSceneView->SetClearColor( Color( 0x00202020 ) );
//spSubCamera->SetSceneViewId( subSceneViewId );
}
#endif
}
#if !HELIUM_RELEASE && !HELIUM_PROFILE
BufferedDrawer& rSceneDrawer = pGraphicsScene->GetSceneBufferedDrawer();
rSceneDrawer.DrawScreenText(
20,
20,
String( TXT( "CACHING" ) ),
Color( 0xff00ff00 ),
RenderResourceManager::DEBUG_FONT_SIZE_LARGE );
rSceneDrawer.DrawScreenText(
21,
20,
String( TXT( "CACHING" ) ),
Color( 0xff00ff00 ),
RenderResourceManager::DEBUG_FONT_SIZE_LARGE );
//rSceneDrawer.Draw
//Helium::DynamicDrawer &drawer = DynamicDrawer::GetStaticInstance();
//drawer.
#endif
}
rWorldManager.Update();
float time = 0.0f;
#if MULTI_WINDOW
spSubRenderContext.Release();
#endif
spMainRenderContext.Release();
Helium::StrongPtr<Helium::Texture2d> texture;
gAssetLoader->LoadObject( AssetPath( TXT( "/Textures:Triangle.png" ) ), texture);
Helium::RTexture2d *rTexture2d = texture->GetRenderResource2d();
while( windowData.bProcessMessages )
{
#if GRAPHICS_SCENE_BUFFERED_DRAWER
BufferedDrawer& rSceneDrawer = pGraphicsScene->GetSceneBufferedDrawer();
rSceneDrawer.DrawScreenText(
20,
20,
String( TXT( "RUNNING" ) ),
Color( 0xffffffff ),
RenderResourceManager::DEBUG_FONT_SIZE_LARGE );
rSceneDrawer.DrawScreenText(
21,
20,
String( TXT( "RUNNING" ) ),
Color( 0xffffffff ),
RenderResourceManager::DEBUG_FONT_SIZE_LARGE );
time += 0.01f;
DynamicArray<SimpleVertex> verticesU;
verticesU.New( -100.0f, -100.0f, 750.0f );
verticesU.New( 100.0f, -100.0f, 750.0f );
verticesU.New( 100.0f, 100.0f, 750.0f );
verticesU.New( -100.0f, 100.0f, 750.0f );
rSceneDrawer.DrawLineList( verticesU.GetData(), static_cast<uint32_t>( verticesU.GetSize() ) );
DynamicArray<SimpleTexturedVertex> verticesT;
verticesT.New( Simd::Vector3( -100.0f, 100.0f, 750.0f ), Simd::Vector2( 0.0f, 0.0f ) );
verticesT.New( Simd::Vector3( 100.0f, 100.0f, 750.0f ), Simd::Vector2( 1.0f, 0.0f ) );
verticesT.New( Simd::Vector3( -100.0f, -100.0f, 750.0f ), Simd::Vector2( 0.0f, 1.0f ) );
verticesT.New( Simd::Vector3( 100.0f, -100.0f, 750.0f ), Simd::Vector2( 1.0f, 1.0f ) );
//rSceneDrawer.DrawTextured(
// RENDERER_PRIMITIVE_TYPE_TRIANGLE_STRIP,
// verticesT.GetData(),
// verticesT.GetSize(),
// NULL,
// 2,
// rTexture2d, Helium::Color(1.0f, 1.0f, 1.0f, 1.0f), Helium::RenderResourceManager::RASTERIZER_STATE_DEFAULT, Helium::RenderResourceManager::DEPTH_STENCIL_STATE_NONE);
//rSceneDrawer.DrawTexturedQuad(rTexture2d);
Helium::Simd::Matrix44 transform = Helium::Simd::Matrix44::IDENTITY;
Simd::Vector3 location(0.0f, 400.0f, 0.0f);
Simd::Quat rotation(Helium::Simd::Vector3::BasisZ, time);
Simd::Vector3 scale(1000.0f, 1000.0f, 1000.0f);
transform.SetRotationTranslationScaling(rotation, location, scale);
rSceneDrawer.DrawTexturedQuad(rTexture2d, transform, Simd::Vector2(0.0f, 0.0f), Simd::Vector2(0.5f, 0.5f));
#endif
//Helium::Simd::Vector3 up = Simd::Vector3::BasisY;
////Helium::Simd::Vector3 eye(5000.0f * sin(time), 0.0f, 5000.0f * cos(time));
//Helium::Simd::Vector3 eye(0.0f, 0.0f, -1000.0f);
//Helium::Simd::Vector3 forward = Simd::Vector3::Zero - eye;
//forward.Normalize();
////pMainSceneView->SetClearColor( Color( 0xffffffff ) );
//pMainSceneView->SetView(eye, forward, up);
if (Input::IsKeyDown(Input::KeyCodes::KC_A))
{
HELIUM_TRACE( TraceLevels::Info, TXT( "A is down" ) );
}
if (Input::IsKeyDown(Input::KeyCodes::KC_ESCAPE))
{
HELIUM_TRACE( TraceLevels::Info, TXT( "Exiting" ) );
break;
}
MSG message;
if( PeekMessage( &message, NULL, 0, 0, PM_REMOVE ) )
{
TranslateMessage( &message );
DispatchMessage( &message );
if( windowData.bShutdownRendering )
{
if( spWorld )
{
spWorld->Shutdown();
}
spWorld.Release();
WorldManager::DestroyStaticInstance();
spSceneDefinition.Release();
spEntityDefinition.Release();
DynamicDrawer::DestroyStaticInstance();
RenderResourceManager::DestroyStaticInstance();
Renderer::DestroyStaticInstance();
break;
}
if( message.message == WM_QUIT )
{
windowData.bProcessMessages = false;
windowData.resultCode = static_cast< int >( message.wParam );
resultCode = static_cast< int >( message.wParam );
break;
}
}
rWorldManager.Update();
#if GRAPHICS_SCENE_BUFFERED_DRAWER
if( pGraphicsScene )
{
BufferedDrawer& rSceneDrawer = pGraphicsScene->GetSceneBufferedDrawer();
rSceneDrawer.DrawScreenText(
20,
20,
String( TXT( "Debug text test!" ) ),
Color( 0xffffffff ) );
}
#endif
}
if( spWorld )
{
spWorld->Shutdown();
}
spWorld.Release();
}
WorldManager::DestroyStaticInstance();
DynamicDrawer::DestroyStaticInstance();
RenderResourceManager::DestroyStaticInstance();
Helium::Input::Cleanup();
Renderer::DestroyStaticInstance();
JobManager::DestroyStaticInstance();
Config::DestroyStaticInstance();
#if HELIUM_TOOLS
AssetPreprocessor::DestroyStaticInstance();
#endif
AssetLoader::DestroyStaticInstance();
CacheManager::DestroyStaticInstance();
Helium::Components::Cleanup();
Reflect::Cleanup();
AssetType::Shutdown();
Asset::Shutdown();
Reflect::ObjectRefCountSupport::Shutdown();
Helium::Bullet::Cleanup();
AssetPath::Shutdown();
Name::Shutdown();
FileLocations::Shutdown();
ThreadLocalStackAllocator::ReleaseMemoryHeap();
#if HELIUM_ENABLE_MEMORY_TRACKING
DynamicMemoryHeap::LogMemoryStats();
ThreadLocalStackAllocator::ReleaseMemoryHeap();
#endif
return resultCode;
}
void Viewport::Draw()
{
HELIUM_EDITOR_SCENE_RENDER_SCOPE_TIMER( "" );
uint64_t start = Timer::GetTickCount();
if (!m_World)
{
return;
}
Camera& camera = m_Cameras[m_CameraMode];
GraphicsScene* pGraphicsScene = GetGraphicsScene();
GraphicsSceneView* pSceneView = pGraphicsScene->GetSceneView( m_SceneViewId );
BufferedDrawer* pDrawer = pGraphicsScene->GetSceneViewBufferedDrawer( m_SceneViewId );
{
HELIUM_EDITOR_SCENE_RENDER_SCOPE_TIMER( "Setup Viewport and Projection" );
pSceneView->SetViewAndProjectionMatrices(
Simd::Matrix44( const_cast<Matrix4&>( camera.GetView() ).GetArray1d() ),
Simd::Matrix44( const_cast<Matrix4&>( camera.GetProjection() ).GetArray1d() )
);
}
pGraphicsScene->SetActiveSceneView( m_SceneViewId );
pGraphicsScene->Update( m_World.Get() );
pGraphicsScene->SetActiveSceneView( Invalid< uint32_t >() );
if (m_GridVisible)
{
m_GlobalPrimitives[GlobalPrimitives::StandardGrid]->Draw( pDrawer );
}
// this seems like a bad place to do this
if (m_Tool)
{
HELIUM_EDITOR_SCENE_RENDER_SCOPE_TIMER( "Tool Evaluate" );
m_Tool->Evaluate();
}
{
HELIUM_EDITOR_SCENE_RENDER_SCOPE_TIMER( "PreRender" );
if (m_GridVisible)
{
m_GlobalPrimitives[GlobalPrimitives::StandardGrid]->Draw( pDrawer );
}
}
{
HELIUM_EDITOR_SCENE_RENDER_SCOPE_TIMER( "Render" );
{
HELIUM_EDITOR_SCENE_RENDER_SCOPE_TIMER( "Render Setup" );
m_RenderVisitor.Reset( this, pDrawer );
}
{
HELIUM_EDITOR_SCENE_RENDER_SCOPE_TIMER( "Render Walk" );
m_Render.Raise( &m_RenderVisitor );
}
if (m_Tool)
{
HELIUM_EDITOR_SCENE_RENDER_SCOPE_TIMER( "Render Tool" );
m_Tool->Draw( pDrawer );
}
}
{
HELIUM_EDITOR_SCENE_RENDER_SCOPE_TIMER( "PostRender" );
//device->Clear(NULL, NULL, D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
if (m_AxesVisible)
{
static_cast<Editor::PrimitiveAxes*>(m_GlobalPrimitives[GlobalPrimitives::ViewportAxes])->DrawViewport( pDrawer, &m_Cameras[m_CameraMode] );
}
if (m_Tool)
{
m_Tool->Draw( pDrawer );
}
#if VIEWPORT_REFACTOR
if ( m_Focused )
{
unsigned w = 3;
unsigned x = m_Size.x;
unsigned y = m_Size.y;
uint32_t color = D3DCOLOR_ARGB(255, 200, 200, 200);
std::vector< TransformedColored > vertices;
// <--
// | \ ^
// v \ |
// -->
// top
vertices.push_back(TransformedColored ((float)0, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)w, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)w, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)0, 1.0f, color));
// bottom
vertices.push_back(TransformedColored ((float)0, (float)y-w, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)y-w, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)y-w, 1.0f, color));
// left
vertices.push_back(TransformedColored ((float)0, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)w, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)w, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)0, (float)0, 1.0f, color));
// right
vertices.push_back(TransformedColored ((float)x-w, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)x-w, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)y, 1.0f, color));
vertices.push_back(TransformedColored ((float)x, (float)0, 1.0f, color));
vertices.push_back(TransformedColored ((float)x-w, (float)0, 1.0f, color));
device->SetRenderState(D3DRS_ZENABLE, FALSE);
device->SetFVF(ElementFormats[ElementTypes::TransformedColored]);
device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, &vertices.front(), sizeof(TransformedColored));
device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, &(vertices[5]), sizeof(TransformedColored));
device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, &(vertices[10]), sizeof(TransformedColored));
device->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, &(vertices[15]), sizeof(TransformedColored));
device->SetRenderState(D3DRS_ZENABLE, TRUE);
}
if (m_DragMode == DragModes::Select)
{
m_SelectionFrame->Draw( &args );
}
#endif
}
}
void GatherInput( PlayerInputComponent *pPlayerInput )
{
float x = 0.0f;
float y = 0.0f;
if ( Helium::Input::IsKeyDown(Input::KeyCodes::KC_LEFT) )
{
x -= 1.0f;
}
if ( Helium::Input::IsKeyDown(Input::KeyCodes::KC_RIGHT) )
{
x += 1.0f;
}
if ( Helium::Input::IsKeyDown(Input::KeyCodes::KC_UP) )
{
y += 1.0f;
}
if ( Helium::Input::IsKeyDown(Input::KeyCodes::KC_DOWN) )
{
y -= 1.0f;
}
pPlayerInput->m_ScreenSpaceFocusPosition = Helium::Input::GetMousePosNormalized();
GraphicsManagerComponent *pGraphics = pPlayerInput->GetWorld()->GetComponents().GetFirst<GraphicsManagerComponent>();
GraphicsSceneView *pSceneView = pGraphics->GetGraphicsScene()->GetSceneView(0);
Simd::Vector3 from;
Simd::Vector3 to;
pSceneView->ConvertNormalizedScreenCoordinatesToRaycast(pPlayerInput->m_ScreenSpaceFocusPosition, from, to);
Simd::Plane plane(Simd::Vector3::BasisZ, -750.0f);
Simd::Vector3 raycastNormalized = (to - from).GetNormalized();
Simd::Vector3 pointOnPlane;
if ( plane.CalculateLineIntersect( from, raycastNormalized, pointOnPlane) )
{
#if GRAPHICS_SCENE_BUFFERED_DRAWER
SimpleVertex verts[2];
verts[0].position[0] = pointOnPlane.GetElement(0) - 30.0f;
verts[0].position[1] = pointOnPlane.GetElement(1);
verts[0].position[2] = pointOnPlane.GetElement(2);
verts[0].color[0] = 0xFF;
verts[0].color[1] = 0xFF;
verts[0].color[2] = 0xFF;
verts[0].color[3] = 0xFF;
verts[1].position[0] = pointOnPlane.GetElement(0) + 30.0f;
verts[1].position[1] = pointOnPlane.GetElement(1);
verts[1].position[2] = pointOnPlane.GetElement(2);
verts[1].color[0] = 0xFF;
verts[1].color[1] = 0xFF;
verts[1].color[2] = 0xFF;
verts[1].color[3] = 0xFF;
pGraphics->GetBufferedDrawer().DrawLineStrip(verts, 2);
verts[0].position[0] = pointOnPlane.GetElement(0);
verts[0].position[1] = pointOnPlane.GetElement(1) - 30.0f;
verts[1].position[0] = pointOnPlane.GetElement(0);
verts[1].position[1] = pointOnPlane.GetElement(1) + 30.0f;
pGraphics->GetBufferedDrawer().DrawLineStrip(verts, 2);
#endif
pPlayerInput->m_bFirePrimary = Helium::Input::IsMouseButtonDown( Helium::Input::MouseButtons::Left );
pPlayerInput->m_WorldSpaceFocusPosition = pointOnPlane;
pPlayerInput->m_bHasWorldSpaceFocus = true;
}
else
{
pPlayerInput->m_bFirePrimary = false;
pPlayerInput->m_WorldSpaceFocusPosition = Simd::Vector3::Zero;
pPlayerInput->m_bHasWorldSpaceFocus = false;
}
pPlayerInput->m_MoveDir = Simd::Vector2(x, y);
pPlayerInput->m_MoveDir.NormalizeOrZero();
}