Esempio n. 1
0
void Pyx::Graphics::Gui::ImGuiImpl::Initialize()
{
    
    if (m_isInitialized)
        Shutdown();

    auto& io = ImGui::GetIO();
    io.IniFilename = nullptr;
    io.LogFilename = nullptr;

	SetupStyle();

    auto* pRenderer = GraphicsContext::GetInstance().GetMainRenderer();
    if (pRenderer)
    {
        switch (pRenderer->GetRendererType())
        {
        case RendererType::D3D9:
        {
            auto* pD3D9Renderer = reinterpret_cast<Renderer::D3D9Renderer*>(pRenderer);
            auto* pDevice9 = pD3D9Renderer->GetDevice();
            if (pDevice9)
            {
                ImGui_ImplDX9_Init(pD3D9Renderer->GetAttachedWindow(), pDevice9);
                if (!m_isResourcesCreated) CreateResources();
                m_isInitialized = true;
            }
            break;
        }
        case RendererType::D3D11:
        {
            auto* pD3D11Renderer = reinterpret_cast<Renderer::D3D11Renderer*>(pRenderer);
            auto* pDevice11 = pD3D11Renderer->GetDevice();
            ID3D11DeviceContext* pDevice11Context = nullptr;
            if (pDevice11)
            {
                pDevice11->GetImmediateContext(&pDevice11Context);
                ImGui_ImplDX11_Init(pD3D11Renderer->GetAttachedWindow(), pDevice11, pDevice11Context);
                pDevice11Context->Release();
                if (!m_isResourcesCreated) CreateResources();
                m_isInitialized = true;
            }
            break;
        }
        default:
            return;
        }
    }
    
}
HRESULT D3D9RenderImpl::Initialize(HWND hDisplayWindow)
{
    m_hDisplayWindow = hDisplayWindow;

    m_pD3D9 = Direct3DCreate9( D3D_SDK_VERSION ); 
    if(!m_pD3D9)
    {
        return E_FAIL;
    }

    HR(m_pD3D9->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &m_displayMode));

    D3DCAPS9 deviceCaps;
    HR(m_pD3D9->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &deviceCaps));

    DWORD dwBehaviorFlags = D3DCREATE_MULTITHREADED;

    if( deviceCaps.VertexProcessingCaps != 0 )
        dwBehaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
    else
        dwBehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
    
    HR(GetPresentParams(&m_presentParams, TRUE));
    
    HR(m_pD3D9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hDisplayWindow, dwBehaviorFlags, &m_presentParams, &m_pDevice));
    
    return CreateResources();
}
Esempio n. 3
0
//*******************************************************************************
void CBCGPTextGaugeImpl::OnDraw(CBCGPGraphicsManager* pGM, const CBCGPRect& /*rectClip*/, DWORD dwFlags)
{
	ASSERT_VALID(pGM);

	if (m_rect.IsRectEmpty() || !m_bIsVisible || m_strText.IsEmpty())
	{
		return;
	}

	if ((dwFlags & m_DefaultDrawFlags) == 0)
	{
		return;
	}

	CBCGPRect rect = m_rect;
	if (m_bIsSubGauge)
	{
		rect.OffsetRect(-m_ptScrollOffset);
	}

	pGM->FillRectangle(rect, GetFillBrush ());

	const CBCGPBrush& br = m_bOff ? m_brTextLight : m_brText;

	CreateResources(CBCGPBrush(), FALSE);
	pGM->DrawText(m_strText, rect, m_textFormat, br);

	pGM->DrawRectangle(rect, GetOutlineBrush (), GetScaleRatioMid());
	
	SetDirty(FALSE);
}
Esempio n. 4
0
//*******************************************************************************
CBCGPSize CBCGPTextGaugeImpl::GetDefaultSize(CBCGPGraphicsManager* pGM, const CBCGPBaseVisualObject* /*pParentGauge*/)
{
	ASSERT_VALID(pGM);

	CreateResources(CBCGPBrush(), FALSE);
	return pGM->GetTextSize(m_strText, m_textFormat);
}
Esempio n. 5
0
bool SetupGame(ResourceManager &resourceManager, const unsigned int lives)
{
    Map map;
    CreateResources(resourceManager);

    return PlayGame(map, resourceManager, lives);
}
Esempio n. 6
0
void CPixelBufferView::OnDeviceReset()
{
	CreateResources();
	m_pixelBufferTexture = CreateTextureFromBitmap(m_pixelBufferBitmap);
	if(!m_checkerboardEffect.IsEmpty()) m_checkerboardEffect->OnResetDevice();
	if(!m_pixelBufferViewEffect.IsEmpty()) m_pixelBufferViewEffect->OnResetDevice();
}
Esempio n. 7
0
//-----------------------------------------------------------------------------
void MySample::Create()
{
    CreateResources();

	ImGui_ImplDX11_Init(GetHWnd(), GetDevice(), GetContext());
	CPUTWindowWin::SetWinProcOverride(MySample_WndProcCallback);
	
    
	int windowWidth, windowHeight;
	mpWindow->GetClientDimensions(&windowWidth, &windowHeight);

	SampleUtil_Init();
	MenuGlob_Init();
	MenuGlob_SetScreenDim(windowWidth, windowHeight);
	MenuController_Init();
	
	std::string userDir = GetUserDataDirectory();
	

#ifndef DISABLE_RSSDK
	MenuController_PushMenu(gMenu_Scan);

	// go directly to the face mapping menu
	//std::string debugFace;
	//CPUTFileSystem::CombinePath(userDir, "joe.obj", &debugFace);
	//gMenu_FaceMapping->LoadFace(debugFace);
	//MenuController_PushMenu(gMenu_FaceMapping);

	// Go directly to the face scan preview menu
	//gMenu_FaceScanPreview->LoadFaceObj("", true);
	//gMenu_FaceScanPreview->SetFaceScanMode( FaceScanPreviewMode_ApproveScan );
	//MenuController_PushMenu(gMenu_FaceScanPreview);
	
#else
	std::string debugFace;
	CPUTFileSystem::CombinePath(userDir, "joe_sr300_1.obj", &debugFace);
	gMenu_FaceMapping->LoadFace( debugFace );
	MenuController_PushMenu(gMenu_FaceMapping);

	// go directly to the face preview menu
	//gMenu_FaceScanPreview->LoadFaceObj("", true);
	//MenuController_PushMenu(gMenu_FaceScanPreview);
	
	// go to the edit landmark menu
	//static CFaceModel faceModel;
	//faceModel.LoadObjFilename(debugFace);
	//gMenu_LandmarkEdit->SetInput(&faceModel.Landmarks, &faceModel.Landmarks, NULL, &faceModel);
	//MenuController_PushMenu(gMenu_LandmarkEdit);

#endif

	MenuGlob_GUI()->SetActivePanel(MENU_CPUT_PANEL_ID);

}
Esempio n. 8
0
//*******************************************************************************
void CBCGPTextGaugeImpl::SetText(const CString& str, const CBCGPBrush& brText, BOOL bRedraw)
{
	m_strText = str;
	CreateResources(brText, TRUE);

	SetDirty();

	if (bRedraw)
	{
		Redraw();
	}
}
Esempio n. 9
0
//*******************************************************************************
void CBCGPTextGaugeImpl::SetText(const CString& str, const CBCGPColor& clrText, BOOL bRedraw)
{
	m_strText = str;
	CreateResources(clrText == CBCGPColor() ? CBCGPBrush() : CBCGPBrush(clrText), FALSE);

	SetDirty();

	if (bRedraw)
	{
		Redraw();
	}
}
void RenderAPI_D3D12::ProcessDeviceEvent(UnityGfxDeviceEventType type, IUnityInterfaces* interfaces)
{
	switch (type)
	{
	case kUnityGfxDeviceEventInitialize:
		s_D3D12 = interfaces->Get<IUnityGraphicsD3D12v2>();
		CreateResources();
		break;
	case kUnityGfxDeviceEventShutdown:
		ReleaseResources();
		break;
	}
}
Esempio n. 11
0
void game::Init(void)
{
  if(g_isConsoleUpdater)
  {
    cmdLine_Init();
    return;
  }
  
  //@gHwInfoPoster.Start(); -- DISABLED FOR NOW

  // set small icon
  ::SendMessage(win::hWnd, WM_SETICON, FALSE, (LPARAM)::LoadIcon(win::hInstance, MAKEINTRESOURCE(IDI_WARINC)));
  
  // make borderless window and subclass wndProc
  r3dWinStyleModify(win::hWnd, 0, WS_BORDER);
  r3dWinStyleModify(win::hWnd, 0, WS_CAPTION);
  SetWindowLong(win::hWnd, GWL_WNDPROC, (DWORD)&updApp_WndFunc);

  // ok, now r3drendered started using vars inside itself...
  RegisterAllVars();

  const int Width  = 785;
  const int Height = 650;

  HDC disp_dc  = CreateIC("DISPLAY", NULL, NULL, NULL);
  int curDispWidth  = GetDeviceCaps(disp_dc, HORZRES);
  int curDispHeight = GetDeviceCaps(disp_dc, VERTRES);
  int StartXPos = (curDispWidth - Width) / 2;
  int StartYPos = (curDispHeight - Height) / 2;
  SetWindowPos(win::hWnd, NULL, StartXPos, StartYPos, (int)Width, (int)Height, 0);

  r3dRenderer = new r3dRenderLayer;
  r3dRenderer->Init(win::hWnd, NULL);
  
  fake_SetMode(Width, Height);
  
  char title[512];
  sprintf(title, "Infestation Thailand Updater %s (%s)", UPDATER_VERSION, UPDATER_BUILD);
  if(!UPDATER_UPDATER_ENABLED) strcat(title, "!!!!SELF_UPDATE_DISABLED!!!");
  ::SetWindowText(win::hWnd, title);

  CreateResources();
  
  ShowWindow(win::hWnd, SW_SHOW);
  
  ClipCursor(NULL);
  
  // release dinput classes becase we won't be using them
  Keyboard->ReleaseCapture();
  Mouse->ReleaseCapture();
}
Esempio n. 12
0
// This sample processes audio buffers during the render cycle of the application.
// As long as the sample maintains a high-enough frame rate, this approach should
// not glitch audio. In game code, it is best for audio buffers to be processed
// on a separate thread that is not synced to the main render loop of the game.
void Audio::Render()
{
    if (m_engineExperiencedCriticalError)
    {
        ReleaseResources();
        Initialize();
        CreateResources();
        Start();
        if (m_engineExperiencedCriticalError)
        {
            return;
        }
    }
}
Esempio n. 13
0
bool
cIpmiMcVendor::CreateRdrs( cIpmiDomain *domain, cIpmiMc *source_mc, cIpmiSdrs *sdrs )
{
  if ( CreateResources( domain, source_mc, sdrs ) == false )
       return false;

  if ( CreateSensors( domain, source_mc, sdrs ) == false )
       return false;

  if ( CreateControls( domain, source_mc, sdrs ) == false )
       return false;

  if ( CreateSels( domain, source_mc, sdrs ) == false )
       return false;

  if ( CreateInvs( domain, source_mc, sdrs ) == false )
       return false;

  return true;
}
Esempio n. 14
0
// GDP = Graphical Data Processor.
bool ImageDraw::GDP ( BYTE * image, unsigned long cbImage)
{
	// Check for inforrectly sized image data.
	if ( cbImage < ((sourceHeight - 1) * sourceStride) + (sourceWidth * 4) )
	{
		return false;
	}

	// create the resources for this device
	// they will be recreated if previously lost
	HRESULT hr = CreateResources();

	if ( FAILED(hr) )
	{
		return false;
	}

	// copy the image that was passed in into the direct2d bitmap
	hr = bitmap->CopyFromMemory( NULL, image, sourceStride);

	if ( FAILED(hr) )
	{
		return false;
	}

	renderTarget->BeginDraw();

	// Draw the bitmap streched to the size of the window.
	renderTarget->DrawBitmap( bitmap );

	hr = renderTarget->EndDraw();

	// Device lost, need to recreate the render target
	// We'll dispose it now and retry drawing.
	if ( hr == D2DERR_RECREATE_TARGET)
	{
		hr = S_OK;
		discardResources();
	}
	return SUCCEEDED( hr );
}	
/*func*------------------------------------------------------------------------
  set color for screen or printer, handle the GDI resources
  in :bScreen     - false: set color of printer element
                    true : set color of screen element
      ColorType   - desired element (COLOR_TYPE)
      ulCol       - color value
  out:-
-----------------------------------------------------------------------------*/
void GDIHelper::SetColor(bool bScreen, COLOR_TYPE ColorType, COLORREF ulCol)
{
   bool bChanged;
   
   ASSERT((ColorType >= 0) || (ColorType < CO_LAST));
   
   if (bScreen) 
   {
      bChanged = ulColor[1][ColorType] != ulCol;
      ulColor[1][ColorType] = ulCol;
   } else {
      bChanged = ulColor[0][ColorType] != ulCol;
      ulColor[0][ColorType] = ulCol;
   }

   if (bChanged)
   {
      DeleteResources();
      CreateResources();
   }
}
Esempio n. 16
0
	bool DX11::Initialise(int a_width, int a_height, bool a_vsync,
		HWND a_hwnd, bool a_fullscreen, float a_screenNear, float a_screenFar)
	{
		// Store common display settings
		m_width = a_width;
		m_height = a_height;
		m_vsync = a_vsync;
		m_fullscreen = a_fullscreen;

		// Initiate renderer
		bool device = CreateDevice(a_hwnd);
		bool resources = CreateResources(a_screenNear, a_screenFar);

#if defined(_DEBUG)
		if (device && resources)
		{
			//m_pDebug->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL);
		}
#endif

		return device && resources;
	}
Esempio n. 17
0
void Graphics::InitializeDirect3d() {

    HRESULT d3dresult;

    /*
    Set some global flags.
    */

    if (config.useDirect3d9Ex) {
        logger->info("Using Direct3D9Ex mode");
        d3dresult = D3DLOG(Direct3DCreate9Ex(D3D_SDK_VERSION, &mDirect3d9));
        if (d3dresult != D3D_OK) {
            throw TempleException("Unable to create Direct3D9 interface.");
        }
    } else {
        logger->info("Using standard Direct3D9 mode");
        mDirect3d9 = static_cast<IDirect3D9Ex*>(Direct3DCreate9(D3D_SDK_VERSION));
        if (!mDirect3d9) {
            throw TempleException("Unable to create Direct3D9 interface.");
        }
    }

    /** START OF OLD WINDOWED INIT */
    // At this point we only do a GetDisplayMode to check the resolution. We could also do this elsewhere
    D3DDISPLAYMODE displayMode;
    d3dresult = D3DLOG(mDirect3d9->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &displayMode));
    if (d3dresult != D3D_OK) {
        throw TempleException("Unable to query display mode for primary adapter.");
    }

    // We need at least 1024x768
    if (displayMode.Width < 1024 || displayMode.Height < 768) {
        throw TempleException("You need at least a display resolution of 1024x768.");
    }

    auto presentParams = CreatePresentParams();

    // presentParams.MultiSampleType = D3DMULTISAMPLE_4_SAMPLES;
    // presentParams.MultiSampleQuality = 0;

    // Nvidia drivers seriously barf on D3d9ex if we use software vertex processing here, as ToEE specifies.
    // I think we are safe with hardware vertex processing, since HW T&L has been standard for more than 10 years.
    if (config.useDirect3d9Ex) {
        logger->info("Creating Direct3D9Ex device.");
        d3dresult = D3DLOG(mDirect3d9->CreateDeviceEx(
                               D3DADAPTER_DEFAULT,
                               D3DDEVTYPE_HAL,
                               mMainWindow.GetHwnd(),
                               D3DCREATE_HARDWARE_VERTEXPROCESSING,
                               &presentParams,
                               nullptr,
                               &mDevice));
    } else {
        logger->info("Creating Direct3D9 device.");
        d3dresult = D3DLOG(mDirect3d9->CreateDevice(
                               D3DADAPTER_DEFAULT,
                               D3DDEVTYPE_HAL,
                               mMainWindow.GetHwnd(),
                               D3DCREATE_HARDWARE_VERTEXPROCESSING,
                               &presentParams,
                               reinterpret_cast<IDirect3DDevice9**>(&mDevice)));
    }

    if (d3dresult != D3D_OK) {
        throw TempleException("Unable to create Direct3D9 device!");
    }

    // TODO: color bullshit is not yet done (tig_d3d_init_handleformat et al)

    // Get the device caps for real this time.
    ReadCaps();

    SetDefaultRenderStates();

    CreateResources();
}
Esempio n. 18
0
//--------------------------------------------------------------------------------------
// Entry point to the program
//--------------------------------------------------------------------------------------
int __cdecl wmain()
{
    // Enable run-time memory check for debug builds.
#if defined(DEBUG) | defined(_DEBUG)
    _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
#endif

    // Generate a random list of numbers to sort
    // Not intended for production code
    srand( GetTickCount() );
    std::generate( data.begin(), data.end(), SampleRand );

    // Create the device
    HRESULT hr = InitDevice();
    if ( FAILED (hr) )
    {
        if ( hr ==  DXUTERR_NODIRECT3D11 ) 
        {
            OSVERSIONINFOEX osv;
            memset( &osv, 0, sizeof(osv) );
            osv.dwOSVersionInfoSize = sizeof(osv);
            GetVersionEx( (LPOSVERSIONINFO)&osv );

            if ( ( osv.dwMajorVersion > 6 )
                || ( osv.dwMajorVersion == 6 && osv.dwMinorVersion >= 1 ) 
                || ( osv.dwMajorVersion == 6 && osv.dwMinorVersion == 0 && osv.dwBuildNumber > 6002 ) )
            {
                MessageBox( 0, L"Direct3D 11 components were not found.", L"Error", MB_ICONEXCLAMATION );
               // This should not happen, but is here for completeness as the system could be
               // corrupted or some future OS version could pull D3D11.DLL for some reason
            }
            else if ( osv.dwMajorVersion == 6 && osv.dwMinorVersion == 0 && osv.dwBuildNumber == 6002 )
            {
                MessageBox( 0, L"Direct3D 11 components were not found, but are available for"\
                L" this version of Windows.\n"\
                L"For details see Microsoft Knowledge Base Article #971644\n"\
                L"http://support.microsoft.com/default.aspx/kb/971644/", L"Error", MB_ICONEXCLAMATION );
            }
            else if ( osv.dwMajorVersion == 6 && osv.dwMinorVersion == 0 )
            {
                MessageBox( 0, L"Direct3D 11 components were not found. Please install the latest Service Pack.\n"\
                L"For details see Microsoft Knowledge Base Article #935791\n"\
                L" http://support.microsoft.com/default.aspx/kb/935791", L"Error", MB_ICONEXCLAMATION );
            }
            else
            {
                MessageBox( 0, L"Direct3D 11 is not supported on this OS.", L"Error", MB_ICONEXCLAMATION );
            }
        }

        printf( "Failed to create the device.  Exiting.\n" );
        return 1;
    }

    // Create the buffers and shaders
    if( FAILED( CreateResources() ) )
    {
        printf( "Failed to create resources.  Exiting.\n" );
        return 1;
    }

    printf( "Sorting %u Elements\n", NUM_ELEMENTS );

    // GPU Bitonic Sort
    printf( "Starting GPU Bitonic Sort...\n" );
    GPUSort();
    printf( "...GPU Bitonic Sort Finished\n" );

    // Sort the data on the CPU to compare for correctness
    printf( "Starting CPU Sort...\n" );
    CPUSort();
    printf( "...CPU Sort Finished\n" );

    // Compare the results for correctness
    bool bComparisonSucceeded = true;
    for( UINT i = 0 ; i < NUM_ELEMENTS ; ++i )
    {
        if( data[i] != results[i] )
        {
            bComparisonSucceeded = false;
            break;
        }
    }
    printf( "Comparison %s\n", (bComparisonSucceeded)? "Succeeded" : "FAILED" );

    // Cleanup the resources
    SAFE_RELEASE( g_pReadBackBuffer );
    SAFE_RELEASE( g_pBuffer2UAV );
    SAFE_RELEASE( g_pBuffer1UAV );
    SAFE_RELEASE( g_pBuffer2SRV );
    SAFE_RELEASE( g_pBuffer1SRV );
    SAFE_RELEASE( g_pBuffer2 );
    SAFE_RELEASE( g_pBuffer1 );
    SAFE_RELEASE( g_pCB );
    SAFE_RELEASE( g_pComputeShaderTranspose );
    SAFE_RELEASE( g_pComputeShaderBitonic );
    SAFE_RELEASE( g_pd3dImmediateContext );
    SAFE_RELEASE( g_pd3dDevice );

    return 0;
}
Esempio n. 19
0
//*******************************************************************************
void CBCGPTextGaugeImpl::SetTextColor(const CBCGPColor& color)
{
	CreateResources(CBCGPBrush(color), FALSE);
	SetDirty();
}
Esempio n. 20
0
void WinConsole::InitAppMode()
{
	SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);

	m_instance = (HINSTANCE)GetModuleHandle(0);
	DWORD processId;
	GetWindowThreadProcessId(GetConsoleWindow(), &processId);

	if (GetCurrentProcessId() == processId && g_ArgumentCount == 1)
	{
		m_initialArguments = (char**)g_Arguments;
		m_initialArgumentCount = g_ArgumentCount;

		// make command line to start in server mode
		m_defaultArguments = (char**)malloc(sizeof(char*) * 3);
		m_defaultArguments[0] = (*g_Arguments)[0];
		m_defaultArguments[1] = "-s";
		m_defaultArguments[2] = nullptr;
		g_Arguments = (char*(*)[])m_defaultArguments;
		g_ArgumentCount = 2;
		m_appMode = true;
	}
	else if (GetCurrentProcessId() == processId && g_ArgumentCount > 1)
	{
		for (int i = 1; i < g_ArgumentCount; i++)
		{
			if (!strcmp((*g_Arguments)[i], "-D"))
			{
				break;
			}
			else if (!strcmp((*g_Arguments)[i], "-app"))
			{
				m_appMode = true;
			}
			else if (!strcmp((*g_Arguments)[i], "-auto"))
			{
				m_autoParam = true;
			}
			else if (!strcmp((*g_Arguments)[i], "-A"))
			{
				m_addParam = true;
			}
		}

		if (m_appMode || m_autoParam)
		{
			m_initialArguments = (char**)g_Arguments;
			m_initialArgumentCount = g_ArgumentCount;

			// remove "-app" from command line
			int argc = g_ArgumentCount - (m_appMode ? 1 : 0) - (m_autoParam ? 1 : 0);
			m_defaultArguments = (char**)malloc(sizeof(char*) * (argc + 2));

			int p = 0;
			for (int i = 0; i < g_ArgumentCount; i++)
			{
				if (strcmp((*g_Arguments)[i], "-app") &&
					strcmp((*g_Arguments)[i], "-auto"))
				{
					m_defaultArguments[p++] = (*g_Arguments)[i];
				}
			}
			m_defaultArguments[p] = nullptr;
			g_Arguments = (char*(*)[])m_defaultArguments;
			g_ArgumentCount = p;
		}
	}

	if (m_addParam)
	{
		RunAnotherInstance();
		return;
	}

	// m_appMode indicates whether the program was started as a standalone app
	// (not from a dos box window). In that case we hide the console window,
	// show the tray icon and start in server mode

	if (m_appMode)
	{
		CreateResources();
		CheckRunning();
	}
}
Esempio n. 21
0
//*******************************************************************************
void CBCGPTextGaugeImpl::SetTextBrush(const CBCGPBrush& brush)
{
	CreateResources(brush, TRUE);
	SetDirty();
}
Esempio n. 22
0
void Pyx::Graphics::Gui::ImGuiImpl::OnFrame()
{
    if (m_isInitialized)
    {

        if (!m_isResourcesCreated)
            CreateResources();

        if (m_isResourcesCreated)
        {
            auto* pRenderer = GraphicsContext::GetInstance().GetMainRenderer();

            if (pRenderer)
            {

                auto& io = ImGui::GetIO();

                if (Input::InputContext::GetInstance().CursorIsVisible() && pRenderer->GetAttachedWindow() == GetForegroundWindow())
                {
                    auto cursorPos = Input::InputContext::GetInstance().GetCursorPosition();
                    ScreenToClient(pRenderer->GetAttachedWindow(), &cursorPos);
                    io.MousePos.x = cursorPos.x;
                    io.MousePos.y = cursorPos.y;
                    io.MouseDown[0] = GetAsyncKeyState(VK_LBUTTON) != 0;
                    io.MouseDown[1] = GetAsyncKeyState(VK_RBUTTON) != 0;
                    io.MouseDown[2] = GetAsyncKeyState(VK_MBUTTON) != 0;
                    io.KeyCtrl = GetAsyncKeyState(VK_CONTROL) != 0;
                    io.KeyShift = GetAsyncKeyState(VK_SHIFT) != 0;
                    io.KeyAlt = GetAsyncKeyState(VK_MENU) != 0;
                }

                switch (pRenderer->GetRendererType())
                {
                case RendererType::D3D9:
                {
                    ImGui_ImplDX9_NewFrame();
                    break;
                }
                case RendererType::D3D11:
                {
                    ImGui_ImplDX11_NewFrame();
                    break;
                }
                default:
                    return;
                }

				if (m_isVisible)
				{

					BuildMainMenuBar();

					if (m_showConsole)
						BuildLogsWindow();

					if (m_showDebugWindow)
						BuildDebugWindow();

					GetOnRenderCallbacks().Run(this);
					Scripting::ScriptingContext::GetInstance().FireCallbacks(XorStringW(L"ImGui.OnRender"));

					ImGui::Render();

				}

            }

			static int lastToggleVisibilityTick = 0;
			if (GetTickCount() - lastToggleVisibilityTick > 250)
			{

				bool shouldToggleGui = true;
				for (auto vKey : PyxContext::GetInstance().GetSettings().GuiToggleVisibilityHotkeys)
				{
					if (GetAsyncKeyState(vKey) == NULL)
					{
						shouldToggleGui = false;
						break;
					}
				}

				if (shouldToggleGui)
				{
					ToggleVisibility(!IsVisible());
					lastToggleVisibilityTick = GetTickCount();
				}

			}

            static int lastToggleConsoleVisibilityTick = 0;
            if (GetTickCount() - lastToggleConsoleVisibilityTick > 250)
            {

                bool shouldToggleConsole = true;
                for (auto vKey : PyxContext::GetInstance().GetSettings().ImGuiToggleConsoleHotkeys)
                {
                    if (GetAsyncKeyState(vKey) == NULL)
                    {
                        shouldToggleConsole = false;
                        break;
                    }
                }

                if (shouldToggleConsole)
                {
                    m_showConsole = !m_showConsole;
                    lastToggleConsoleVisibilityTick = GetTickCount();
                }

            }

        }

    }

}
Esempio n. 23
0
HRESULT GaussianMain::OnD3D11CreateDevice( ID3D11Device* pd3dDevice)
{
	//HRESULT hr;

	ID3D11DeviceContext* pd3dImmediateContext;
	pd3dDevice->GetImmediateContext(&pd3dImmediateContext);

	// Load effect
	LoadEffectFromFile(pd3dDevice, L"gaussian_vs_ps.hlsl", &g_pFX_Render);

	// Layout for full screen quad rendering
	const D3D11_INPUT_ELEMENT_DESC quad_layout[] =
	{
		{"POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
		{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 16, D3D11_INPUT_PER_VERTEX_DATA, 0},
	};
	D3DX11_PASS_DESC pass_desc;
	g_pFX_Render->GetTechniqueByName("Tech_ShowImage")->GetPassByName("Pass_ShowMonoImage")->GetDesc(&pass_desc);
	pd3dDevice->CreateInputLayout(quad_layout, 2, pass_desc.pIAInputSignature, pass_desc.IAInputSignatureSize, &g_pQuadLayout);

	// Vertex buffer for full screen quad rendering
	SCREEN_VERTEX svQuad[4];
	svQuad[0].pos = D3DXVECTOR4( -1.0f, 1.0f, 0.5f, 1.0f );
	svQuad[0].tex = D3DXVECTOR2( 0.0f, 0.0f );
	svQuad[1].pos = D3DXVECTOR4( 1.0f, 1.0f, 0.5f, 1.0f );
	svQuad[1].tex = D3DXVECTOR2( 1.0f, 0.0f );
	svQuad[2].pos = D3DXVECTOR4( -1.0f, -1.0f, 0.5f, 1.0f );
	svQuad[2].tex = D3DXVECTOR2( 0.0f, 1.0f );
	svQuad[3].pos = D3DXVECTOR4( 1.0f, -1.0f, 0.5f, 1.0f );
	svQuad[3].tex = D3DXVECTOR2( 1.0f, 1.0f );

	D3D11_BUFFER_DESC vbdesc =
	{
		4 * sizeof( SCREEN_VERTEX ),
		D3D11_USAGE_IMMUTABLE,
		D3D11_BIND_VERTEX_BUFFER,
		0,
		0
	};
	D3D11_SUBRESOURCE_DATA InitData;
	InitData.pSysMem = svQuad;
	InitData.SysMemPitch = 0;
	InitData.SysMemSlicePitch = 0;
	pd3dDevice->CreateBuffer( &vbdesc, &InitData, &g_pScreenQuadVB );

	//---------------------------------
	//resize swap chain
	//---------------------------------

	CreateResources(pd3dDevice, &GetDXGIBackBufferSurfaceDesc());

	// Save render target and viewport
	pd3dImmediateContext->OMGetRenderTargets(1, &g_pRTV_Default, &g_pDSV_Default);
	UINT nViewPorts = 1;
	pd3dImmediateContext->RSGetViewports(&nViewPorts, g_VP_Default);
	SAFE_RELEASE(pd3dImmediateContext);

	//----------------------------------
	// frame move
	//----------------------------------
	// Compile the shaders if haven't.
	SAFE_RELEASE(g_pFX_GaussianCol);
	SAFE_RELEASE(g_pFX_GaussianRow);
	CompileGaussianFilterEffects(pd3dDevice, &GetDXGIBackBufferSurfaceDesc());

	return S_OK;
}
//--------------------------------------------------------------------------------------
// Entry point to the program
//--------------------------------------------------------------------------------------
int __cdecl wmain()
{
    // Enable run-time memory check for debug builds.
#if defined(DEBUG) | defined(_DEBUG)
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif

    // Generate a random list of numbers to sort
    // Not intended for production code
    srand(GetTickCount());
    std::generate(data.begin(), data.end(), SampleRand);

    // Create the device
    HRESULT hr = InitDevice();
    if (FAILED(hr))
    {
        if (hr == DXUTERR_NODIRECT3D)
        {
            MessageBox(0, L"Direct3D 11 components were not found.\n"
                L"For details see Microsoft Knowledge Base\n"
                L"https://support.microsoft.com/",
                L"Error", MB_ICONEXCLAMATION);
        }

        printf("Failed to create the device.  Exiting.\n");
        return 1;
    }

    // Create the buffers and shaders
    if (FAILED(CreateResources()))
    {
        printf("Failed to create resources.  Exiting.\n");
        return 1;
    }

    printf("Sorting %u Elements\n", NUM_ELEMENTS);

    // GPU Bitonic Sort
    printf("Starting GPU Bitonic Sort...\n");
    GPUSort();
    printf("...GPU Bitonic Sort Finished\n");

    // Sort the data on the CPU to compare for correctness
    printf("Starting CPU Sort...\n");
    CPUSort();
    printf("...CPU Sort Finished\n");

    // Compare the results for correctness
    bool bComparisonSucceeded = true;
    for (UINT i = 0; i < NUM_ELEMENTS; ++i)
    {
        if (data[i] != results[i])
        {
            bComparisonSucceeded = false;
            break;
        }
    }
    printf("Comparison %s\n", (bComparisonSucceeded) ? "Succeeded" : "FAILED");

    // Cleanup the resources
    SAFE_RELEASE(g_pReadBackBuffer);
    SAFE_RELEASE(g_pBuffer2UAV);
    SAFE_RELEASE(g_pBuffer1UAV);
    SAFE_RELEASE(g_pBuffer2SRV);
    SAFE_RELEASE(g_pBuffer1SRV);
    SAFE_RELEASE(g_pBuffer2);
    SAFE_RELEASE(g_pBuffer1);
    SAFE_RELEASE(g_pCB);
    SAFE_RELEASE(g_pComputeShaderTranspose);
    SAFE_RELEASE(g_pComputeShaderBitonic);
    SAFE_RELEASE(g_pd3dImmediateContext);
    SAFE_RELEASE(g_pd3dDevice);

    return 0;
}
Esempio n. 25
0
void CPixelBufferView::OnDeviceReset()
{
	CreateResources();
	CreateSelectedPixelBufferTexture();
}