ShuriZma
/
xenia
mirror of https://github.com/xenia-project/xenia.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

D3D11 window up and spinning.

This commit is contained in:
Ben Vanik 2013-10-11 20:23:58 -07:00
parent 611d3bbbeb
commit 6e4fb87992
33 changed files with 1184 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/xenia/core.h
View File

@ -18,7 +18,13 @@
#include <xenia/core/mutex.h>
#include <xenia/core/pal.h>
#include <xenia/core/ref.h>
#include <xenia/core/run_loop.h>
#include <xenia/core/socket.h>
#include <xenia/core/thread.h>
#include <xenia/core/window.h>
#if XE_PLATFORM(WIN32)
#include <xenia/core/win32_window.h>
#endif // WIN32
#endif // XENIA_CORE_H_

33
src/xenia/core/run_loop.h Normal file
View File

@ -0,0 +1,33 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_CORE_RUN_LOOP_H_
#define XENIA_CORE_RUN_LOOP_H_
#include <xenia/common.h>
#include <xenia/core/ref.h>
struct xe_run_loop;
typedef struct xe_run_loop* xe_run_loop_ref;
xe_run_loop_ref xe_run_loop_create();
xe_run_loop_ref xe_run_loop_retain(xe_run_loop_ref run_loop);
void xe_run_loop_release(xe_run_loop_ref run_loop);
int xe_run_loop_pump(xe_run_loop_ref run_loop);
void xe_run_loop_quit(xe_run_loop_ref run_loop);
typedef void (*xe_run_loop_callback)(void* data);
void xe_run_loop_call(xe_run_loop_ref run_loop,
xe_run_loop_callback callback, void* data);
#endif // XENIA_CORE_RUN_LOOP_H_

83
src/xenia/core/run_loop_win.cc Normal file
View File

@ -0,0 +1,83 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <xenia/core/run_loop.h>
#include <xenia/core/mutex.h>
#include <xenia/core/thread.h>
typedef struct xe_run_loop {
xe_ref_t ref;
} xe_run_loop_t;
#define WM_XE_RUN_LOOP_QUIT (WM_APP + 0x100)
#define WM_XE_RUN_LOOP_CALL (WM_APP + 0x101)
typedef struct xe_run_loop_call {
xe_run_loop_callback callback;
void* data;
} xe_run_loop_call_t;
xe_run_loop_ref xe_run_loop_create() {
xe_run_loop_ref run_loop = (xe_run_loop_ref)xe_calloc(sizeof(xe_run_loop_t));
xe_ref_init((xe_ref)run_loop);
return run_loop;
}
void xe_run_loop_dealloc(xe_run_loop_ref run_loop) {
}
xe_run_loop_ref xe_run_loop_retain(xe_run_loop_ref run_loop) {
xe_ref_retain((xe_ref)run_loop);
return run_loop;
}
void xe_run_loop_release(xe_run_loop_ref run_loop) {
xe_ref_release((xe_ref)run_loop, (xe_ref_dealloc_t)xe_run_loop_dealloc);
}
int xe_run_loop_pump(xe_run_loop_ref run_loop) {
MSG msg;
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
switch (msg.message) {
case WM_XE_RUN_LOOP_CALL:
if (msg.wParam == (WPARAM)run_loop) {
xe_run_loop_call_t* call = (xe_run_loop_call_t*)msg.lParam;
call->callback(call->data);
xe_free(call);
}
break;
case WM_XE_RUN_LOOP_QUIT:
if (msg.lParam == (WPARAM)run_loop) {
// Done!
return 1;
}
break;
}
}
return 0;
}
void xe_run_loop_quit(xe_run_loop_ref run_loop) {
PostMessage(NULL, WM_XE_RUN_LOOP_QUIT, 0, (WPARAM)run_loop);
}
void xe_run_loop_call(xe_run_loop_ref run_loop,
xe_run_loop_callback callback, void* data) {
xe_run_loop_call_t* call =
(xe_run_loop_call_t*)xe_calloc(sizeof(xe_run_loop_call_t));
call->callback = callback;
call->data = data;
PostMessage(NULL, WM_XE_RUN_LOOP_CALL, (WPARAM)run_loop, (LPARAM)call);
}

6
src/xenia/core/sources.gypi
View File

@ -12,9 +12,12 @@
'path.h',
'ref.cc',
'ref.h',
'run_loop.h',
'socket.h',
'thread.cc',
'thread.h',
'window.cc',
'window.h',
],
'conditions': [
@ -42,7 +45,10 @@
'mutex_win.cc',
'pal_win.cc',
'path_win.cc',
'run_loop_win.cc',
'socket_win.cc',
'win32_window.cc',
'win32_window.h',
],
}],
],

244
src/xenia/core/win32_window.cc Normal file
View File

@ -0,0 +1,244 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <xenia/core/win32_window.h>
#include <dwmapi.h>
#include <tpcshrd.h>
using namespace xe;
using namespace xe::core;
namespace {
static LRESULT CALLBACK Win32WindowWndProc(
HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
Win32Window* window = 0;
if (message == WM_NCCREATE) {
LPCREATESTRUCT create_struct = (LPCREATESTRUCT)lParam;
window = (Win32Window*)create_struct->lpCreateParams;
SetWindowLongPtr(hWnd, GWLP_USERDATA, (__int3264)(LONG_PTR)window);
} else {
window = (Win32Window*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
}
if (window) {
return window->WndProc(hWnd, message, wParam, lParam);
} else {
return DefWindowProc(hWnd, message, wParam, lParam);
}
}
}
Win32Window::Win32Window(xe_run_loop_ref run_loop) :
handle_(0),
Window(run_loop) {
Create();
}
Win32Window::~Win32Window() {
if (handle_) {
CloseWindow(handle_);
}
}
void Win32Window::Create() {
HINSTANCE hInstance = GetModuleHandle(NULL);
width_ = 1280;
height_ = 720;
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = Win32WindowWndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = NULL; // LoadIcon(hInstance, (LPCTSTR)IDI_TUTORIAL1);
wcex.hIconSm = NULL; // LoadIcon(hInstance, (LPCTSTR)IDI_TUTORIAL1);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1 );
wcex.lpszMenuName = NULL;
wcex.lpszClassName = L"XeniaWindowClass";
if (!RegisterClassEx(&wcex)) {
XELOGE("RegisterClassEx failed");
exit(1);
return;
}
// Setup initial size.
DWORD window_style = WS_OVERLAPPEDWINDOW;
DWORD window_ex_style = WS_EX_APPWINDOW;
RECT rc = {
0, 0,
width_, height_
};
AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
// Create window.
handle_ = CreateWindowEx(
window_ex_style,
L"XeniaWindowClass",
L"Xenia",
window_style,
CW_USEDEFAULT, CW_USEDEFAULT,
rc.right - rc.left, rc.bottom - rc.top,
NULL,
NULL,
hInstance,
this);
if (!handle_) {
XELOGE("CreateWindow failed");
exit(1);
return;
}
// Disable flicks.
ATOM atom = GlobalAddAtom(L"MicrosoftTabletPenServiceProperty");
const DWORD_PTR dwHwndTabletProperty =
TABLET_DISABLE_PRESSANDHOLD | // disables press and hold (right-click) gesture
TABLET_DISABLE_PENTAPFEEDBACK | // disables UI feedback on pen up (waves)
TABLET_DISABLE_PENBARRELFEEDBACK | // disables UI feedback on pen button down (circle)
TABLET_DISABLE_FLICKS | // disables pen flicks (back, forward, drag down, drag up)
TABLET_DISABLE_TOUCHSWITCH |
TABLET_DISABLE_SMOOTHSCROLLING |
TABLET_DISABLE_TOUCHUIFORCEON |
TABLET_ENABLE_MULTITOUCHDATA;
SetProp(
handle_,
L"MicrosoftTabletPenServiceProperty",
reinterpret_cast<HANDLE>(dwHwndTabletProperty));
GlobalDeleteAtom(atom);
// Enable DWM elevation.
EnableMMCSS();
ShowWindow(handle_, SW_SHOWNORMAL);
UpdateWindow(handle_);
}
void Win32Window::EnableMMCSS() {
HMODULE hLibrary = LoadLibrary(L"DWMAPI.DLL");
if (!hLibrary) {
return;
}
typedef HRESULT (__stdcall *PDwmEnableMMCSS)(BOOL);
PDwmEnableMMCSS pDwmEnableMMCSS =
(PDwmEnableMMCSS)GetProcAddress(
hLibrary, "DwmEnableMMCSS");
if (pDwmEnableMMCSS) {
pDwmEnableMMCSS(TRUE);
}
typedef HRESULT (__stdcall *PDwmSetPresentParameters)(HWND, DWM_PRESENT_PARAMETERS*);
PDwmSetPresentParameters pDwmSetPresentParameters =
(PDwmSetPresentParameters)GetProcAddress(
hLibrary, "DwmSetPresentParameters");
if (pDwmSetPresentParameters) {
DWM_PRESENT_PARAMETERS pp;
memset(&pp, 0, sizeof(DWM_PRESENT_PARAMETERS));
pp.cbSize = sizeof(DWM_PRESENT_PARAMETERS);
pp.fQueue = FALSE;
pp.cBuffer = 2;
pp.fUseSourceRate = FALSE;
pp.cRefreshesPerFrame = 1;
pp.eSampling = DWM_SOURCE_FRAME_SAMPLING_POINT;
pDwmSetPresentParameters(handle_, &pp);
}
FreeLibrary( hLibrary );
}
void Win32Window::set_title(const xechar_t* title) {
XEIGNORE(SetWindowText(handle_, title));
}
void Win32Window::Resize(uint32_t width, uint32_t height) {
if (width == width_ && height == height_) {
return;
}
width_ = width;
height_ = height;
RECT rc = {
0, 0,
width_, height_
};
AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
// TODO(benvanik): center.
MoveWindow(handle_, 0, 0, rc.right - rc.left, rc.bottom - rc.top, TRUE);
OnResize(width_, height_);
}
void Win32Window::ShowError(const xechar_t* message) {
XEIGNORE(MessageBox(handle_, message, L"Xenia Error", MB_ICONERROR | MB_OK));
}
LRESULT Win32Window::WndProc(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam) {
switch (message) {
case WM_NCCREATE:
handle_ = hWnd;
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_ACTIVATEAPP:
if (wParam) {
// Made active.
} else {
// Made inactive.
}
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_CLOSE:
OnClose();
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
}
return 0;
case WM_ERASEBKGND:
return 0; // ignore
case WM_DISPLAYCHANGE:
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_MOVE:
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_SIZE:
{
RECT frame;
GetClientRect(handle_, &frame);
OnResize(frame.right - frame.left, frame.bottom - frame.top);
}
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_TABLET_QUERYSYSTEMGESTURESTATUS:
return
TABLET_DISABLE_PRESSANDHOLD | // disables press and hold (right-click) gesture
TABLET_DISABLE_PENTAPFEEDBACK | // disables UI feedback on pen up (waves)
TABLET_DISABLE_PENBARRELFEEDBACK | // disables UI feedback on pen button down (circle)
TABLET_DISABLE_FLICKS | // disables pen flicks (back, forward, drag down, drag up)
TABLET_DISABLE_TOUCHSWITCH |
TABLET_DISABLE_SMOOTHSCROLLING |
TABLET_DISABLE_TOUCHUIFORCEON |
TABLET_ENABLE_MULTITOUCHDATA;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
}

49
src/xenia/core/win32_window.h Normal file
View File

@ -0,0 +1,49 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_CORE_WIN32_WINDOW_H_
#define XENIA_CORE_WIN32_WINDOW_H_
#include <xenia/common.h>
#include <xenia/core/window.h>
namespace xe {
namespace core {
class Win32Window : public Window {
public:
Win32Window(xe_run_loop_ref run_loop);
virtual ~Win32Window();
HWND handle() const { return handle_; }
virtual void set_title(const xechar_t* title);
virtual void Resize(uint32_t width, uint32_t height);
virtual void ShowError(const xechar_t* message);
LRESULT WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
protected:
HWND handle_;
private:
void Create();
void EnableMMCSS();
};
} // namespace core
} // namespace xe
#endif // XENIA_CORE_WIN32_WINDOW_H_

23
src/xenia/core/window.cc Normal file
View File

@ -0,0 +1,23 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <xenia/core/window.h>
using namespace xe;
using namespace xe::core;
Window::Window(xe_run_loop_ref run_loop) {
run_loop_ = xe_run_loop_retain(run_loop);
}
Window::~Window() {
xe_run_loop_release(run_loop_);
}

51
src/xenia/core/window.h Normal file
View File

@ -0,0 +1,51 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_CORE_WINDOW_H_
#define XENIA_CORE_WINDOW_H_
#include <xenia/common.h>
#include <xenia/core/pal.h>
#include <xenia/core/ref.h>
#include <xenia/core/run_loop.h>
namespace xe {
namespace core {
class Window {
public:
Window(xe_run_loop_ref run_loop);
virtual ~Window();
virtual void set_title(const xechar_t* title) = 0;
uint32_t width() const { return width_; }
uint32_t height() const { return height_; }
virtual void Resize(uint32_t width, uint32_t height) = 0;
virtual void ShowError(const xechar_t* message) = 0;
protected:
virtual void OnResize(uint32_t width, uint32_t height) {}
virtual void OnClose() {}
xe_run_loop_ref run_loop_;
uint32_t width_;
uint32_t height_;
};
} // namespace core
} // namespace xe
#endif // XENIA_CORE_WINDOW_H_

6
src/xenia/gpu/d3d11/d3d11_graphics_driver.cc
View File

@ -19,11 +19,15 @@ using namespace xe::gpu::d3d11;
using namespace xe::gpu::xenos;
D3D11GraphicsDriver::D3D11GraphicsDriver(xe_memory_ref memory) :
D3D11GraphicsDriver::D3D11GraphicsDriver(
xe_memory_ref memory, ID3D11Device* device) :
GraphicsDriver(memory) {
device_ = device;
device_->AddRef();
}
D3D11GraphicsDriver::~D3D11GraphicsDriver() {
device_->Release();
}
void D3D11GraphicsDriver::Initialize() {

7
src/xenia/gpu/d3d11/d3d11_graphics_driver.h
View File

@ -16,6 +16,8 @@
#include <xenia/gpu/d3d11/d3d11-private.h>
#include <xenia/gpu/xenos/xenos.h>
#include <d3d11.h>
namespace xe {
namespace gpu {
@ -24,7 +26,7 @@ namespace d3d11 {
class D3D11GraphicsDriver : public GraphicsDriver {
public:
D3D11GraphicsDriver(xe_memory_ref memory);
D3D11GraphicsDriver(xe_memory_ref memory, ID3D11Device* device);
virtual ~D3D11GraphicsDriver();
virtual void Initialize();
@ -40,7 +42,8 @@ public:
xenos::XE_GPU_PRIMITIVE_TYPE prim_type,
uint32_t index_count);
protected:
private:
ID3D11Device* device_;
};

111
src/xenia/gpu/d3d11/d3d11_graphics_system.cc
View File

@ -11,6 +11,7 @@
#include <xenia/gpu/gpu-private.h>
#include <xenia/gpu/d3d11/d3d11_graphics_driver.h>
#include <xenia/gpu/d3d11/d3d11_window.h>
using namespace xe;
@ -18,14 +19,120 @@ using namespace xe::gpu;
using namespace xe::gpu::d3d11;
namespace {
}
D3D11GraphicsSystem::D3D11GraphicsSystem(const CreationParams* params) :
window_(0), dxgi_factory_(0), device_(0),
GraphicsSystem(params) {
}
D3D11GraphicsSystem::~D3D11GraphicsSystem() {
if (device_) device_->Release();
if (dxgi_factory_) dxgi_factory_->Release();
delete window_;
}
void D3D11GraphicsSystem::Initialize() {
XEASSERTNULL(driver_);
driver_ = new D3D11GraphicsDriver(memory_);
GraphicsSystem::Initialize();
// Create DXGI factory so we can get a swap chain/etc.
HRESULT hr = CreateDXGIFactory1(__uuidof(IDXGIFactory1),
(void**)&dxgi_factory_);
if (FAILED(hr)) {
XELOGE("CreateDXGIFactory1 failed with %.8X", hr);
exit(1);
return;
}
// Find the best adapter.
// TODO(benvanik): enable nvperfhud/etc.
IDXGIAdapter1* adapter = 0;
UINT n = 0;
while (dxgi_factory_->EnumAdapters1(n, &adapter) != DXGI_ERROR_NOT_FOUND) {
DXGI_ADAPTER_DESC1 desc;
adapter->GetDesc1(&desc);
adapter->Release();
n++;
}
// Just go with the default for now.
adapter = 0;
D3D_DRIVER_TYPE driver_type =
adapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE;
UINT flags = 0;
// TODO(benvanik): runtime flag
flags |= D3D11_CREATE_DEVICE_DEBUG;
// Feature level 11.0+ only.
D3D_FEATURE_LEVEL feature_levels[] = {
D3D_FEATURE_LEVEL_11_0,
};
// Create device.
D3D_FEATURE_LEVEL actual_feature_level;
ID3D11DeviceContext* immediate_context;
hr = D3D11CreateDevice(
adapter,
driver_type,
0, // software driver HMODULE
flags,
feature_levels,
XECOUNT(feature_levels),
D3D11_SDK_VERSION,
&device_,
&actual_feature_level,
&immediate_context);
if (adapter) {
adapter->Release();
adapter = 0;
}
if (immediate_context) {
immediate_context->Release();
immediate_context = 0;
}
if (FAILED(hr)) {
XELOGE("D3D11CreateDevice failed with %.8X", hr);
exit(1);
return;
}
// Create the window.
// This will pump through the run-loop and and be where our swapping
// will take place.
XEASSERTNULL(window_);
window_ = new D3D11Window(run_loop_, dxgi_factory_, device_);
window_->set_title(XETEXT("Xenia D3D11"));
// Listen for alt-enter/etc.
dxgi_factory_->MakeWindowAssociation(window_->handle(), 0);
// Create the driver.
// This runs in the worker thread and builds command lines to present
// in the window.
XEASSERTNULL(driver_);
driver_ = new D3D11GraphicsDriver(memory_, device_);
// Initial vsync kick.
DispatchInterruptCallback();
}
void D3D11GraphicsSystem::Pump() {
if (swap_pending_) {
swap_pending_ = false;
// Swap window.
// If we are set to vsync this will block.
window_->Swap();
// Dispatch interrupt callback to let the game know it can keep drawing.
DispatchInterruptCallback();
}
}
void D3D11GraphicsSystem::Shutdown() {
GraphicsSystem::Shutdown();
}

12
src/xenia/gpu/d3d11/d3d11_graphics_system.h
View File

@ -15,11 +15,15 @@
#include <xenia/gpu/graphics_system.h>
#include <xenia/gpu/d3d11/d3d11-private.h>
#include <d3d11.h>
namespace xe {
namespace gpu {
namespace d3d11 {
class D3D11Window;
GraphicsSystem* Create(const CreationParams* params);
@ -29,7 +33,15 @@ public:
D3D11GraphicsSystem(const CreationParams* params);
virtual ~D3D11GraphicsSystem();
protected:
virtual void Initialize();
virtual void Pump();
virtual void Shutdown();
private:
IDXGIFactory1* dxgi_factory_;
ID3D11Device* device_;
D3D11Window* window_;
};

22
src/xenia/gpu/d3d11/d3d11_shader.cc Normal file
View File

@ -0,0 +1,22 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <xenia/gpu/d3d11/d3d11_shader.h>
using namespace xe;
using namespace xe::gpu;
using namespace xe::gpu::d3d11;
D3D11Shader::D3D11Shader() {
}
D3D11Shader::~D3D11Shader() {
}

35
src/xenia/gpu/d3d11/d3d11_shader.h Normal file
View File

@ -0,0 +1,35 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_GPU_D3D11_D3D11_SHADER_H_
#define XENIA_GPU_D3D11_D3D11_SHADER_H_
#include <xenia/core.h>
#include <xenia/gpu/shader.h>
namespace xe {
namespace gpu {
namespace d3d11 {
class D3D11Shader : public Shader {
public:
D3D11Shader();
virtual ~D3D11Shader();
};
} // namespace d3d11
} // namespace gpu
} // namespace xe
#endif // XENIA_GPU_D3D11_D3D11_SHADER_H_

22
src/xenia/gpu/d3d11/d3d11_shader_cache.cc Normal file
View File

@ -0,0 +1,22 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <xenia/gpu/d3d11/d3d11_shader_cache.h>
using namespace xe;
using namespace xe::gpu;
using namespace xe::gpu::d3d11;
D3D11ShaderCache::D3D11ShaderCache() {
}
D3D11ShaderCache::~D3D11ShaderCache() {
}

35
src/xenia/gpu/d3d11/d3d11_shader_cache.h Normal file
View File

@ -0,0 +1,35 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_GPU_D3D11_D3D11_SHADER_CACHE_H_
#define XENIA_GPU_D3D11_D3D11_SHADER_CACHE_H_
#include <xenia/core.h>
#include <xenia/gpu/shader_cache.h>
namespace xe {
namespace gpu {
namespace d3d11 {
class D3D11ShaderCache : public ShaderCache {
public:
D3D11ShaderCache();
virtual ~D3D11ShaderCache();
};
} // namespace d3d11
} // namespace gpu
} // namespace xe
#endif // XENIA_GPU_D3D11_D3D11_SHADER_CACHE_H_

124
src/xenia/gpu/d3d11/d3d11_window.cc Normal file
View File

@ -0,0 +1,124 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <xenia/gpu/d3d11/d3d11_window.h>
using namespace xe;
using namespace xe::core;
using namespace xe::gpu;
using namespace xe::gpu::d3d11;
D3D11Window::D3D11Window(
xe_run_loop_ref run_loop,
IDXGIFactory1* dxgi_factory, ID3D11Device* device) :
Win32Window(run_loop) {
dxgi_factory_ = dxgi_factory;
dxgi_factory_->AddRef();
device_ = device;
device_->AddRef();
device_->GetImmediateContext(&context_);
swap_chain_ = 0;
render_target_view_ = 0;
// Setup swap chain.
DXGI_SWAP_CHAIN_DESC desc;
xe_zero_struct(&desc, sizeof(desc));
desc.OutputWindow = handle_;
desc.Windowed = TRUE;
desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
desc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
// Setup buffers.
desc.BufferCount = 2;
desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
desc.BufferDesc.Width = width_;
desc.BufferDesc.Height = height_;
desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.BufferDesc.RefreshRate.Numerator = 60;
desc.BufferDesc.RefreshRate.Denominator = 1;
// Disable multisampling.
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
// Create!
HRESULT hr = dxgi_factory_->CreateSwapChain(
device_,
&desc,
&swap_chain_);
if (FAILED(hr)) {
XELOGE("CreateSwapChain failed with %.8X", hr);
exit(1);
return;
}
// Create a render target view to draw into.
ID3D11Texture2D* back_buffer = 0;
hr = swap_chain_->GetBuffer(
0, __uuidof(ID3D11Texture2D), (void**)&back_buffer);
if (FAILED(hr)) {
XELOGE("GetBuffer (back_buffer) failed with %.8X", hr);
exit(1);
return;
}
hr = device_->CreateRenderTargetView(
back_buffer, NULL, &render_target_view_);
back_buffer->Release();
if (FAILED(hr)) {
XELOGE("CreateRenderTargetView (back_buffer) failed with %.8X", hr);
exit(1);
return;
}
context_->OMSetRenderTargets(1, &render_target_view_, NULL);
}
D3D11Window::~D3D11Window() {
if (render_target_view_) render_target_view_->Release();
if (context_) {
context_->ClearState();
context_->Release();
}
if (swap_chain_) swap_chain_->Release();
if (device_) device_->Release();
if (dxgi_factory_) dxgi_factory_->Release();
}
void D3D11Window::Swap() {
// Setup the viewport.
//D3D11_VIEWPORT viewport;
//viewport.MinDepth = 0.0f;
//viewport.MaxDepth = 1.0f;
//viewport.TopLeftX = 0;
//viewport.TopLeftY = 0;
//viewport.Width = (FLOAT)width_;
//viewport.Height = (FLOAT)height_;
//context_->RSSetViewports(1, &viewport);
// Swap buffers.
// TODO(benvanik): control vsync with flag.
bool vsync = true;
HRESULT hr = swap_chain_->Present(vsync ? 1 : 0, 0);
if (FAILED(hr)) {
XELOGE("Present failed with %.8X", hr);
}
}
void D3D11Window::OnResize(uint32_t width, uint32_t height) {
Win32Window::OnResize(width, height);
// TODO(benvanik): resize swap buffers?
}
void D3D11Window::OnClose() {
// We are the master window - if they close us, quit!
xe_run_loop_quit(run_loop_);
}

50
src/xenia/gpu/d3d11/d3d11_window.h Normal file
View File

@ -0,0 +1,50 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_GPU_D3D11_D3D11_WINDOW_H_
#define XENIA_GPU_D3D11_D3D11_WINDOW_H_
#include <xenia/core.h>
#include <d3d11.h>
namespace xe {
namespace gpu {
namespace d3d11 {
class D3D11Window : public xe::core::Win32Window {
public:
D3D11Window(
xe_run_loop_ref run_loop,
IDXGIFactory1* dxgi_factory, ID3D11Device* device);
virtual ~D3D11Window();
void Swap();
protected:
virtual void OnResize(uint32_t width, uint32_t height);
virtual void OnClose();
private:
IDXGIFactory1* dxgi_factory_;
ID3D11Device* device_;
IDXGISwapChain* swap_chain_;
ID3D11DeviceContext* context_;
ID3D11RenderTargetView* render_target_view_;
};
} // namespace d3d11
} // namespace gpu
} // namespace xe
#endif // XENIA_GPU_D3D11_D3D11_WINDOW_H_

6
src/xenia/gpu/d3d11/sources.gypi
View File

@ -8,5 +8,11 @@
'd3d11_graphics_driver.h',
'd3d11_graphics_system.cc',
'd3d11_graphics_system.h',
'd3d11_shader.cc',
'd3d11_shader.h',
'd3d11_shader_cache.cc',
'd3d11_shader_cache.h',
'd3d11_window.cc',
'd3d11_window.h',
],
}

60
src/xenia/gpu/graphics_system.cc
View File

@ -21,19 +21,39 @@ using namespace xe::gpu::xenos;
GraphicsSystem::GraphicsSystem(const CreationParams* params) :
interrupt_callback_(0), interrupt_callback_data_(0) {
interrupt_callback_(0), interrupt_callback_data_(0),
swap_pending_(false) {
memory_ = xe_memory_retain(params->memory);
worker_ = new RingBufferWorker(memory_);
// Set during Initialize();
driver_ = 0;
// Create the run loop used for any windows/etc.
// This must be done on the thread we create the driver.
run_loop_ = xe_run_loop_create();
// Create worker thread.
// This will initialize the graphics system.
// Init needs to happen there so that any thread-local stuff
// is created on the right thread.
running_ = true;
thread_ = xe_thread_create(
"GraphicsSystem",
(xe_thread_callback)ThreadStartThunk, this);
xe_thread_start(thread_);
}
GraphicsSystem::~GraphicsSystem() {
// TODO(benvanik): thread join.
running_ = false;
xe_thread_release(thread_);
// TODO(benvanik): worker join/etc.
delete worker_;
xe_run_loop_release(run_loop_);
xe_memory_release(memory_);
}
@ -49,6 +69,44 @@ void GraphicsSystem::set_processor(shared_ptr<cpu::Processor> processor) {
processor_ = processor;
}
void GraphicsSystem::ThreadStart() {
xe_run_loop_ref run_loop = xe_run_loop_retain(run_loop_);
// Initialize driver and ringbuffer.
Initialize();
XEASSERTNOTNULL(driver_);
// Main run loop.
while (running_) {
// Peek main run loop.
if (xe_run_loop_pump(run_loop)) {
break;
}
if (!running_) {
break;
}
// Pump worker.
worker_->Pump();
// Pump graphics system.
Pump();
}
running_ = false;
Shutdown();
xe_run_loop_release(run_loop);
// TODO(benvanik): call module API to kill?
}
void GraphicsSystem::Initialize() {
}
void GraphicsSystem::Shutdown() {
}
void GraphicsSystem::SetInterruptCallback(uint32_t callback,
uint32_t user_data) {
interrupt_callback_ = callback;

23
src/xenia/gpu/graphics_system.h
View File

@ -31,7 +31,9 @@ class CreationParams {
public:
xe_memory_ref memory;
CreationParams() : memory(NULL) {}
CreationParams() :
memory(0) {
}
};
@ -43,7 +45,6 @@ public:
shared_ptr<cpu::Processor> processor();
void set_processor(shared_ptr<cpu::Processor> processor);
virtual void Initialize() = 0;
void SetInterruptCallback(uint32_t callback, uint32_t user_data);
void InitializeRingBuffer(uint32_t ptr, uint32_t page_count);
void EnableReadPointerWriteBack(uint32_t ptr, uint32_t block_size);
@ -52,6 +53,8 @@ public:
virtual void WriteRegister(uint32_t r, uint64_t value);
void DispatchInterruptCallback();
bool swap_pending() const { return swap_pending_; }
void set_swap_pending(bool value) { swap_pending_ = value; }
public:
// TODO(benvanik): have an HasRegisterHandler() so that the JIT can
@ -64,17 +67,33 @@ public:
this_ptr->WriteRegister(r, value);
}
protected:
virtual void Initialize();
virtual void Pump() = 0;
virtual void Shutdown();
private:
static void ThreadStartThunk(GraphicsSystem* this_ptr) {
this_ptr->ThreadStart();
}
void ThreadStart();
protected:
GraphicsSystem(const CreationParams* params);
xe_memory_ref memory_;
shared_ptr<cpu::Processor> processor_;
xe_run_loop_ref run_loop_;
xe_thread_ref thread_;
bool running_;
GraphicsDriver* driver_;
RingBufferWorker* worker_;
uint32_t interrupt_callback_;
uint32_t interrupt_callback_data_;
bool swap_pending_;
};

22
src/xenia/gpu/nop/nop_graphics_system.cc
View File

@ -34,15 +34,11 @@ NopGraphicsSystem::NopGraphicsSystem(const CreationParams* params) :
}
NopGraphicsSystem::~NopGraphicsSystem() {
if (vsync_timer_) {
DeleteTimerQueueTimer(timer_queue_, vsync_timer_, NULL);
}
if (timer_queue_) {
DeleteTimerQueueEx(timer_queue_, NULL);
}
}
void NopGraphicsSystem::Initialize() {
GraphicsSystem::Initialize();
XEASSERTNULL(driver_);
driver_ = new NopGraphicsDriver(memory_);
@ -59,3 +55,17 @@ void NopGraphicsSystem::Initialize() {
100,
WT_EXECUTEINTIMERTHREAD);
}
void NopGraphicsSystem::Pump() {
}
void NopGraphicsSystem::Shutdown() {
if (vsync_timer_) {
DeleteTimerQueueTimer(timer_queue_, vsync_timer_, NULL);
}
if (timer_queue_) {
DeleteTimerQueueEx(timer_queue_, NULL);
}
GraphicsSystem::Shutdown();
}

3
src/xenia/gpu/nop/nop_graphics_system.h
View File

@ -26,7 +26,10 @@ public:
NopGraphicsSystem(const CreationParams* params);
virtual ~NopGraphicsSystem();
protected:
virtual void Initialize();
virtual void Pump();
virtual void Shutdown();
private:
HANDLE timer_queue_;

28
src/xenia/gpu/ring_buffer_worker.cc
View File

@ -21,20 +21,12 @@ using namespace xe::gpu::xenos;
RingBufferWorker::RingBufferWorker(xe_memory_ref memory) :
memory_(memory), driver_(0) {
running_ = true;
write_ptr_index_event_ = CreateEvent(
NULL, FALSE, FALSE, NULL);
thread_ = xe_thread_create(
"RingBufferWorker",
(xe_thread_callback)ThreadStartThunk, this);
}
RingBufferWorker::~RingBufferWorker() {
// TODO(benvanik): thread join.
running_ = false;
SetEvent(write_ptr_index_event_);
xe_thread_release(thread_);
CloseHandle(write_ptr_index_event_);
}
@ -44,8 +36,6 @@ void RingBufferWorker::Initialize(GraphicsDriver* driver,
primary_buffer_ptr_ = ptr;
primary_buffer_size_ = page_count * 4 * 1024;
read_ptr_index_ = 0;
xe_thread_start(thread_);
}
void RingBufferWorker::EnableReadPointerWriteBack(uint32_t ptr,
@ -64,21 +54,22 @@ void RingBufferWorker::UpdateWritePointer(uint32_t value) {
SetEvent(write_ptr_index_event_);
}
void RingBufferWorker::ThreadStart() {
void RingBufferWorker::Pump() {
uint8_t* p = xe_memory_addr(memory_);
while (running_) {
if (write_ptr_index_ == 0xBAADF00D ||
read_ptr_index_ == write_ptr_index_) {
// Wait for the command buffer pointer to move.
// TODO(benvanik): only wait for a bit and check running_.
WaitForSingleObject(write_ptr_index_event_, INFINITE);
if (!running_) {
break;
// Check if the pointer has moved.
// We wait a short bit here to yield time. Since we are also running the
// main window display we don't want to pause too long, though.
const int wait_time_ms = 1;
if (WaitForSingleObject(write_ptr_index_event_,
wait_time_ms) == WAIT_TIMEOUT) {
return;
}
}
if (read_ptr_index_ == write_ptr_index_) {
continue;
return;
}
// Process the new commands.
@ -99,7 +90,6 @@ void RingBufferWorker::ThreadStart() {
XESETUINT32BE(p + read_ptr_writeback_ptr_, read_ptr_index_);
}
}
}
void RingBufferWorker::ExecuteSegment(uint32_t ptr, uint32_t length) {
uint8_t* p = xe_memory_addr(memory_);

8
src/xenia/gpu/ring_buffer_worker.h
View File

@ -33,17 +33,13 @@ public:
void UpdateWritePointer(uint32_t value);
void Pump();
protected:
static void ThreadStartThunk(RingBufferWorker* this_ptr) {
this_ptr->ThreadStart();
}
void ThreadStart();
void ExecuteSegment(uint32_t ptr, uint32_t length);
protected:
xe_memory_ref memory_;
xe_thread_ref thread_;
bool running_;
GraphicsDriver* driver_;

21
src/xenia/gpu/shader.cc Normal file
View File

@ -0,0 +1,21 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <xenia/gpu/shader.h>
using namespace xe;
using namespace xe::gpu;
Shader::Shader() {
}
Shader::~Shader() {
}

31
src/xenia/gpu/shader.h Normal file
View File

@ -0,0 +1,31 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_GPU_SHADER_H_
#define XENIA_GPU_SHADER_H_
#include <xenia/core.h>
namespace xe {
namespace gpu {
class Shader {
public:
Shader();
virtual ~Shader();
};
} // namespace gpu
} // namespace xe
#endif // XENIA_GPU_SHADER_H_

21
src/xenia/gpu/shader_cache.cc Normal file
View File

@ -0,0 +1,21 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <xenia/gpu/shader_cache.h>
using namespace xe;
using namespace xe::gpu;
ShaderCache::ShaderCache() {
}
ShaderCache::~ShaderCache() {
}

31
src/xenia/gpu/shader_cache.h Normal file
View File

@ -0,0 +1,31 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_GPU_SHADER_CACHE_H_
#define XENIA_GPU_SHADER_CACHE_H_
#include <xenia/core.h>
namespace xe {
namespace gpu {
class ShaderCache {
public:
ShaderCache();
virtual ~ShaderCache();
};
} // namespace gpu
} // namespace xe
#endif // XENIA_GPU_SHADER_CACHE_H_

4
src/xenia/gpu/sources.gypi
View File

@ -11,6 +11,10 @@
'graphics_system.h',
'ring_buffer_worker.cc',
'ring_buffer_worker.h',
'shader.cc',
'shader.h',
'shader_cache.cc',
'shader_cache.h',
],
'includes': [

21
src/xenia/kernel/modules/xboxkrnl/xboxkrnl_video.cc
View File

@ -154,8 +154,6 @@ void xeVdInitializeEngines(uint32_t unk0, uint32_t callback, uint32_t unk1,
// r4 = function ptr (cleanup callback?)
// r5 = 0
// r6/r7 = some binary data in .data
gs->Initialize();
}
@ -366,6 +364,24 @@ SHIM_CALL VdRetrainEDRAM_shim(
}
SHIM_CALL VdSwap_shim(
xe_ppc_state_t* ppc_state, KernelState* state) {
XELOGD(
"VdSwap(?)");
KernelState* kernel_state = shared_kernel_state_;
XEASSERTNOTNULL(kernel_state);
GraphicsSystem* gs = kernel_state->processor()->graphics_system().get();
if (!gs) {
return;
}
gs->set_swap_pending(true);
SHIM_SET_RETURN(0);
}
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
@ -387,6 +403,7 @@ void xe::kernel::xboxkrnl::RegisterVideoExports(
SHIM_SET_MAPPING("xboxkrnl.exe", VdPersistDisplay, state);
SHIM_SET_MAPPING("xboxkrnl.exe", VdRetrainEDRAMWorker, state);
SHIM_SET_MAPPING("xboxkrnl.exe", VdRetrainEDRAM, state);
SHIM_SET_MAPPING("xboxkrnl.exe", VdSwap, state);
xe_memory_ref memory = state->memory();
uint8_t* mem = xe_memory_addr(memory);

7
tools/xenia-run/xenia-run.cc
View File

@ -33,6 +33,7 @@ public:
private:
xe_memory_ref memory_;
xe_run_loop_ref run_loop_;
shared_ptr<Backend> backend_;
shared_ptr<GraphicsSystem> graphics_system_;
shared_ptr<Processor> processor_;
@ -40,10 +41,12 @@ private:
shared_ptr<Debugger> debugger_;
};
Run::Run() {
Run::Run() :
memory_(0), run_loop_(0) {
}
Run::~Run() {
xe_run_loop_release(run_loop_);
xe_memory_release(memory_);
}
@ -62,7 +65,7 @@ int Run::Setup() {
backend_ = shared_ptr<Backend>(new xe::cpu::x64::X64Backend());
params.memory = memory_;
graphics_system_ = shared_ptr<GraphicsSystem>(xe::gpu::CreateNop(&params));
graphics_system_ = shared_ptr<GraphicsSystem>(xe::gpu::Create(&params));
debugger_ = shared_ptr<Debugger>(new Debugger());

3
xenia.gyp
View File

@ -40,6 +40,9 @@
['OS == "win"', {
'libraries': [
'wsock32',
'dxgi',
'd3d11',
'd3dx11',
],
}],
['OS == "mac"', {