mirrors/bgfx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:bkaradzic/bgfx

Browse Source
This commit is contained in:
Branimir Karadzic 2014-11-15 16:11:21 -08:00
commit c805b36cba
13 changed files with 386 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
README.md
View File

@ -25,6 +25,7 @@ Supported platforms:
* OSX (10.9)
* RaspberryPi
* Windows (XP, Vista, 7, 8, 10)
* WinRT (WinPhone 8.0+)
Supported compilers:
@ -662,7 +663,7 @@ Dario Manesku ([@dariomanesku](https://github.com/dariomanesku)) - 13-stencil,
James Gray ([@james4k](https://github.com/james4k)) - Go language API bindings.
p0nce ([@p0nce](https://github.com/p0nce)) - D language API bindings.
Mike Popoloski ([@MikePopoloski](https://github.com/MikePopoloski)) - C#/VB/F#
language API bindings
language API bindings, WinRT/WinPhone support.
[License (BSD 2-clause)](https://github.com/bkaradzic/bgfx/blob/master/LICENSE)
-------------------------------------------------------------------------------

192
examples/common/entry/entry_winrt.cpp Normal file
View File

@ -0,0 +1,192 @@
/*
* Copyright 2011-2014 Branimir Karadzic. All rights reserved.
* License: http://www.opensource.org/licenses/BSD-2-Clause
*/
#include "entry_p.h"
#if BX_PLATFORM_WINRT
#include <bgfxplatform.h>
#include <bx/thread.h>
using namespace Windows::ApplicationModel;
using namespace Windows::ApplicationModel::Core;
using namespace Windows::ApplicationModel::Activation;
using namespace Windows::UI::Core;
using namespace Windows::UI::Input;
using namespace Windows::System;
using namespace Windows::Foundation;
using namespace Windows::Graphics::Display;
using namespace Platform;
static char* g_emptyArgs[] = { "" };
static entry::WindowHandle g_defaultWindow = { 0 };
static entry::EventQueue g_eventQueue;
ref class App sealed : public IFrameworkView
{
public:
App()
: m_windowVisible(true)
, m_windowClosed(false)
{
}
// IFrameworkView Methods.
virtual void Initialize(CoreApplicationView^ applicationView)
{
applicationView->Activated += ref new TypedEventHandler<CoreApplicationView^, IActivatedEventArgs^>(this, &App::OnActivated);
}
virtual void SetWindow(CoreWindow^ window)
{
window->VisibilityChanged += ref new TypedEventHandler<CoreWindow^, VisibilityChangedEventArgs^>(this, &App::OnVisibilityChanged);
window->Closed += ref new TypedEventHandler<CoreWindow^, CoreWindowEventArgs^>(this, &App::OnWindowClosed);
bgfx::winrtSetWindow(reinterpret_cast<IUnknown*>(window));
}
virtual void Load(String^ entryPoint)
{
}
virtual void Run()
{
bx::Thread thread;
thread.init(MainThreadFunc, nullptr);
CoreWindow^ window = CoreWindow::GetForCurrentThread();
if (window == nullptr) {
int i = 4;
i++;
}
//auto bounds = window->Bounds;
//g_eventQueue.postSizeEvent(g_defaultWindow, bounds.Width, bounds.Height);
while (!m_windowClosed)
{
if (m_windowVisible)
{
window->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
}
else
{
window->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending);
}
}
g_eventQueue.postExitEvent();
thread.shutdown();
}
virtual void Uninitialize()
{
}
private:
bool m_windowVisible;
bool m_windowClosed;
void OnActivated(CoreApplicationView^ applicationView, IActivatedEventArgs^ args)
{
CoreWindow^ window = CoreWindow::GetForCurrentThread();
if (window == nullptr) {
int i = 4;
i++;
}
CoreWindow::GetForCurrentThread()->Activate();
}
void OnVisibilityChanged(CoreWindow^ sender, VisibilityChangedEventArgs^ args)
{
m_windowVisible = args->Visible;
}
void OnWindowClosed(CoreWindow^ sender, CoreWindowEventArgs^ args)
{
m_windowClosed = true;
}
static int32_t MainThreadFunc(void*)
{
return entry::main(0, g_emptyArgs);
}
};
ref class AppSource sealed : IFrameworkViewSource
{
public:
virtual IFrameworkView^ CreateView()
{
return ref new App();
}
};
namespace entry
{
const Event* poll()
{
return g_eventQueue.poll();
}
const Event* poll(WindowHandle _handle)
{
return g_eventQueue.poll(_handle);
}
void release(const Event* _event)
{
g_eventQueue.release(_event);
}
WindowHandle createWindow(int32_t _x, int32_t _y, uint32_t _width, uint32_t _height, uint32_t _flags, const char* _title)
{
BX_UNUSED(_x, _y, _width, _height, _flags, _title);
WindowHandle handle = { UINT16_MAX };
return handle;
}
void destroyWindow(WindowHandle _handle)
{
BX_UNUSED(_handle);
}
void setWindowPos(WindowHandle _handle, int32_t _x, int32_t _y)
{
BX_UNUSED(_handle, _x, _y);
}
void setWindowSize(WindowHandle _handle, uint32_t _width, uint32_t _height)
{
BX_UNUSED(_handle, _width, _height);
}
void setWindowTitle(WindowHandle _handle, const char* _title)
{
BX_UNUSED(_handle, _title);
}
void toggleWindowFrame(WindowHandle _handle)
{
BX_UNUSED(_handle);
}
void setMouseLock(WindowHandle _handle, bool _lock)
{
BX_UNUSED(_handle, _lock);
}
}
[MTAThread]
int main(Array<String^>^)
{
auto appSource = ref new AppSource();
CoreApplication::Run(appSource);
return 0;
}
#endif // BX_PLATFORM_WINRT

11
examples/common/font/font_manager.cpp
View File

@ -5,7 +5,18 @@
#define USE_EDTAA3 0
#include "bx/platform.h"
#if BX_COMPILER_MSVC
#define generic GenericFromFreeType // WinRT language extensions see "generic" as a keyword... this is stupid
#define interface InterfaceFromFreeType
#pragma warning(push)
#pragma warning(disable : 4245) // conversion from 'int' to 'FT_UInt', signed/unsigned mismatch
#include <freetype/freetype.h>
#pragma warning(pop)
#else
#include <freetype/freetype.h>
#endif
#include "../common.h"

10
include/bgfxplatform.h
View File

@ -91,6 +91,16 @@ namespace bgfx
} // namespace bgfx
#elif BX_PLATFORM_WINRT
# include <Unknwn.h>
namespace bgfx
{
///
void winrtSetWindow(IUnknown* _window);
} // namespace bgfx
#endif // BX_PLATFORM_
#if defined(_SDL_H)

5
scripts/bgfx.lua
View File

@ -49,6 +49,11 @@ function bgfxProject(_name, _kind, _defines)
"$(DXSDK_DIR)/include",
}
configuration { "winphone8*"}
linkoptions {
"/ignore:4264" -- LNK4264: archiving object file compiled with /ZW into a static library; note that when authoring Windows Runtime types it is not recommended to link with a static library that contains Windows Runtime metadata
}
configuration { "xcode4 or osx or ios*" }
files {
BGFX_DIR .. "src/**.mm",

5
scripts/example-common.lua
View File

@ -31,3 +31,8 @@ project ("example-common")
includedirs {
BX_DIR .. "include/compat/osx",
}
configuration { "winphone8*"}
linkoptions {
"/ignore:4264" -- LNK4264: archiving object file compiled with /ZW into a static library; note that when authoring Windows Runtime types it is not recommended to link with a static library that contains Windows Runtime metadata
}

22
scripts/genie.lua
View File

@ -70,7 +70,10 @@ function exampleProject(_name)
configuration {}
debugdir (BGFX_DIR .. "examples/runtime/")
-- don't output debugdir for winphone builds
if "winphone81" ~= _OPTIONS["vs"] then
debugdir (BGFX_DIR .. "examples/runtime/")
end
includedirs {
BX_DIR .. "include",
@ -149,6 +152,23 @@ function exampleProject(_name)
"psapi",
}
configuration { "winphone8*"}
removelinks {
"DelayImp",
"gdi32",
"psapi"
}
links {
"d3d11",
"dxgi"
}
linkoptions {
"/ignore:4264" -- LNK4264: archiving object file compiled with /ZW into a static library; note that when authoring Windows Runtime types it is not recommended to link with a static library that contains Windows Runtime metadata
}
-- WinRT targets need their own output directories are build files stomp over each other
targetdir (BGFX_BUILD_DIR .. "arm_" .. _ACTION .. "/bin/" .. _name)
objdir (BGFX_BUILD_DIR .. "arm_" .. _ACTION .. "/obj/" .. _name)
configuration { "mingw*" }
links {
"dxguid",

11
src/bgfx.cpp
View File

@ -46,6 +46,13 @@ namespace bgfx
{
g_bgfxHwnd = _window;
}
#elif BX_PLATFORM_WINRT
::IUnknown* g_bgfxCoreWindow = NULL;
void winrtSetWindow(::IUnknown* _window)
{
g_bgfxCoreWindow = _window;
}
#endif // BX_PLATFORM_*
#if BGFX_CONFIG_USE_TINYSTL
@ -1386,6 +1393,10 @@ again:
{
_type = RendererType::OpenGLES;
}
else if (BX_ENABLED(BX_PLATFORM_WINRT))
{
_type = RendererType::Direct3D11;
}
else
{
_type = RendererType::OpenGL;

2
src/bgfx_p.h
View File

@ -198,6 +198,8 @@ namespace bgfx
extern void* g_bgfxNSWindow;
#elif BX_PLATFORM_WINDOWS
extern ::HWND g_bgfxHwnd;
#elif BX_PLATFORM_WINRT
extern ::IUnknown* g_bgfxCoreWindow;
#endif // BX_PLATFORM_*
struct Clear

2
src/config.h
View File

@ -29,6 +29,7 @@
# ifndef BGFX_CONFIG_RENDERER_DIRECT3D11
# define BGFX_CONFIG_RENDERER_DIRECT3D11 (0 \
|| (BX_PLATFORM_WINDOWS && BX_PLATFORM_WINDOWS >= 0x0601 /*_WIN32_WINNT_WIN7*/) \
|| BX_PLATFORM_WINRT \
? 1 : 0)
# endif // BGFX_CONFIG_RENDERER_DIRECT3D11
@ -149,6 +150,7 @@
|| BX_PLATFORM_RPI \
|| BX_PLATFORM_WINDOWS \
|| BX_PLATFORM_XBOX360 \
|| BX_PLATFORM_WINRT \
? 1 : 0) )
#endif // BGFX_CONFIG_MULTITHREADED

127
src/renderer_d3d11.cpp
View File

@ -613,8 +613,14 @@ RENDERDOC_IMPORT
HRESULT hr;
IDXGIFactory* factory;
#if BX_PLATFORM_WINRT
// WinRT requires the IDXGIFactory2 interface, which isn't supported on older platforms
hr = CreateDXGIFactory1(__uuidof(IDXGIFactory2), (void**)&factory);
BGFX_FATAL(SUCCEEDED(hr), Fatal::UnableToInitialize, "Unable to create DXGI factory.");
#else
hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
BGFX_FATAL(SUCCEEDED(hr), Fatal::UnableToInitialize, "Unable to create DXGI factory.");
#endif // BX_PLATFORM_WINRT
m_adapter = NULL;
m_driverType = D3D_DRIVER_TYPE_HARDWARE;
@ -699,6 +705,31 @@ RENDERDOC_IMPORT
hr = adapter->GetDesc(&m_adapterDesc);
BGFX_FATAL(SUCCEEDED(hr), Fatal::UnableToInitialize, "Unable to create Direct3D11 device.");
#if BX_PLATFORM_WINRT
hr = adapter->GetParent(__uuidof(IDXGIFactory2), (void**)&m_factory);
BGFX_FATAL(SUCCEEDED(hr), Fatal::UnableToInitialize, "Unable to create Direct3D11 device.");
DX_RELEASE(adapter, 2);
memset(&m_scd, 0, sizeof(m_scd) );
m_scd.Width = BGFX_DEFAULT_WIDTH;
m_scd.Height = BGFX_DEFAULT_HEIGHT;
m_scd.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
m_scd.Stereo = false;
m_scd.SampleDesc.Count = 1;
m_scd.SampleDesc.Quality = 0;
m_scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
m_scd.BufferCount = 2;
m_scd.Scaling = DXGI_SCALING_NONE;
m_scd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
m_scd.AlphaMode = DXGI_ALPHA_MODE_IGNORE;
hr = m_factory->CreateSwapChainForCoreWindow(m_device
, g_bgfxCoreWindow
, &m_scd
, NULL
, &m_swapChain
);
#else
hr = adapter->GetParent(__uuidof(IDXGIFactory), (void**)&m_factory);
BGFX_FATAL(SUCCEEDED(hr), Fatal::UnableToInitialize, "Unable to create Direct3D11 device.");
DX_RELEASE(adapter, 2);
@ -720,6 +751,7 @@ RENDERDOC_IMPORT
, &m_scd
, &m_swapChain
);
#endif // BX_PLATFORM_WINRT
BGFX_FATAL(SUCCEEDED(hr), Fatal::UnableToInitialize, "Failed to create swap chain.");
m_numWindows = 1;
@ -1085,8 +1117,8 @@ RENDERDOC_IMPORT
{
ID3D11DeviceContext* deviceCtx = m_deviceCtx;
uint32_t width = m_scd.BufferDesc.Width;
uint32_t height = m_scd.BufferDesc.Height;
uint32_t width = getBufferWidth();
uint32_t height = getBufferHeight();
if (m_ovr.isEnabled() )
{
m_ovr.getSize(width, height);
@ -1175,8 +1207,8 @@ RENDERDOC_IMPORT
DX_RELEASE(color, 0);
D3D11_TEXTURE2D_DESC dsd;
dsd.Width = m_scd.BufferDesc.Width;
dsd.Height = m_scd.BufferDesc.Height;
dsd.Width = getBufferWidth();
dsd.Height = getBufferHeight();
dsd.MipLevels = 1;
dsd.ArraySize = 1;
dsd.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
@ -1262,7 +1294,7 @@ RENDERDOC_IMPORT
{
uint32_t msaa = s_checkMsaa[ii];
uint32_t quality = 0;
HRESULT hr = m_device->CheckMultisampleQualityLevels(m_scd.BufferDesc.Format, msaa, &quality);
HRESULT hr = m_device->CheckMultisampleQualityLevels(getBufferFormat(), msaa, &quality);
if (SUCCEEDED(hr)
&& 0 < quality)
@ -1283,11 +1315,14 @@ RENDERDOC_IMPORT
bool recenter = !!(_resolution.m_flags & BGFX_RESET_HMD_RECENTER);
uint32_t flags = _resolution.m_flags & ~BGFX_RESET_HMD_RECENTER;
if ( (uint32_t)m_scd.BufferDesc.Width != _resolution.m_width
|| (uint32_t)m_scd.BufferDesc.Height != _resolution.m_height
if ( getBufferWidth() != _resolution.m_width
|| getBufferHeight() != _resolution.m_height
|| m_flags != flags)
{
bool resize = (m_flags&BGFX_RESET_MSAA_MASK) == (flags&BGFX_RESET_MSAA_MASK);
#if BX_PLATFORM_WINRT
resize = false; // can't use ResizeBuffers on Windows Phone
#endif
m_flags = flags;
m_textVideoMem.resize(false, _resolution.m_width, _resolution.m_height);
@ -1296,17 +1331,16 @@ RENDERDOC_IMPORT
m_resolution = _resolution;
m_resolution.m_flags = flags;
m_scd.BufferDesc.Width = _resolution.m_width;
m_scd.BufferDesc.Height = _resolution.m_height;
setBufferSize(_resolution.m_width, _resolution.m_height);
preReset();
if (resize)
{
DX_CHECK(m_swapChain->ResizeBuffers(2
, m_scd.BufferDesc.Width
, m_scd.BufferDesc.Height
, m_scd.BufferDesc.Format
, getBufferWidth()
, getBufferHeight()
, getBufferFormat()
, DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH
) );
}
@ -1317,11 +1351,21 @@ RENDERDOC_IMPORT
DX_RELEASE(m_swapChain, 0);
#if BX_PLATFORM_WINRT
HRESULT hr;
hr = m_factory->CreateSwapChainForCoreWindow(m_device
, g_bgfxCoreWindow
, &m_scd
, NULL
, &m_swapChain
);
#else
HRESULT hr;
hr = m_factory->CreateSwapChain(m_device
, &m_scd
, &m_swapChain
);
#endif
BGFX_FATAL(SUCCEEDED(hr), bgfx::Fatal::UnableToInitialize, "Failed to create swap chain.");
}
@ -1745,6 +1789,44 @@ RENDERDOC_IMPORT
return sampler;
}
DXGI_FORMAT getBufferFormat()
{
#if BX_PLATFORM_WINRT
return m_scd.Format;
#else
return m_scd.BufferDesc.Format;
#endif
}
uint32_t getBufferWidth()
{
#if BX_PLATFORM_WINRT
return m_scd.Width;
#else
return m_scd.BufferDesc.Width;
#endif
}
uint32_t getBufferHeight()
{
#if BX_PLATFORM_WINRT
return m_scd.Height;
#else
return m_scd.BufferDesc.Height;
#endif
}
void setBufferSize(uint32_t _width, uint32_t _height)
{
#if BX_PLATFORM_WINRT
m_scd.Width = _width;
m_scd.Height = _height;
#else
m_scd.BufferDesc.Width = _width;
m_scd.BufferDesc.Height = _height;
#endif
}
void commitTextureStage()
{
m_deviceCtx->PSSetShaderResources(0, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS, m_textureStage.m_srv);
@ -1900,22 +1982,20 @@ RENDERDOC_IMPORT
ID3D11Texture2D* backBuffer;
DX_CHECK(m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backBuffer) );
DXGI_MODE_DESC& desc = m_scd.BufferDesc;
if (NULL == m_captureResolve)
{
m_deviceCtx->CopyResource(m_captureTexture, backBuffer);
}
else
{
m_deviceCtx->ResolveSubresource(m_captureResolve, 0, backBuffer, 0, desc.Format);
m_deviceCtx->ResolveSubresource(m_captureResolve, 0, backBuffer, 0, getBufferFormat());
m_deviceCtx->CopyResource(m_captureTexture, m_captureResolve);
}
D3D11_MAPPED_SUBRESOURCE mapped;
DX_CHECK(m_deviceCtx->Map(m_captureTexture, 0, D3D11_MAP_READ, 0, &mapped) );
g_callback->captureFrame(mapped.pData, desc.Height*mapped.RowPitch);
g_callback->captureFrame(mapped.pData, getBufferHeight()*mapped.RowPitch);
m_deviceCtx->Unmap(m_captureTexture, 0);
@ -2012,8 +2092,8 @@ RENDERDOC_IMPORT
void clearQuad(ClearQuad& _clearQuad, const Rect& _rect, const Clear& _clear, const float _palette[][4])
{
uint32_t width = m_scd.BufferDesc.Width;
uint32_t height = m_scd.BufferDesc.Height;
uint32_t width = getBufferWidth();
uint32_t height = getBufferHeight();
if (0 == _rect.m_x
&& 0 == _rect.m_y
@ -2146,9 +2226,14 @@ RENDERDOC_IMPORT
D3D_DRIVER_TYPE m_driverType;
IDXGIAdapter* m_adapter;
DXGI_ADAPTER_DESC m_adapterDesc;
#if BX_PLATFORM_WINRT
IDXGIFactory2* m_factory;
IDXGISwapChain1* m_swapChain;
#else
IDXGIFactory* m_factory;
IDXGISwapChain* m_swapChain;
#endif
IDXGISwapChain* m_swapChain;
uint16_t m_lost;
uint16_t m_numWindows;
FrameBufferHandle m_windows[BGFX_CONFIG_MAX_FRAME_BUFFERS];
@ -2166,7 +2251,11 @@ RENDERDOC_IMPORT
Resolution m_resolution;
bool m_wireframe;
#if BX_PLATFORM_WINRT
DXGI_SWAP_CHAIN_DESC1 m_scd;
#else
DXGI_SWAP_CHAIN_DESC m_scd;
#endif
uint32_t m_flags;
IndexBufferD3D11 m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS];

4
src/renderer_d3d11.h
View File

@ -18,7 +18,11 @@ BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wunknown-pragmas" );
BX_PRAGMA_DIAGNOSTIC_IGNORED_GCC("-Wpragmas");
BX_PRAGMA_DIAGNOSTIC_IGNORED_MSVC(4005) // warning C4005: '' : macro redefinition
#define D3D11_NO_HELPERS
#if BX_PLATFORM_WINRT
#include <d3d11_2.h>
#else
#include <d3d11.h>
#endif
BX_PRAGMA_DIAGNOSTIC_POP()
#include "renderer_d3d.h"

13
src/renderer_d3d12.cpp
View File

@ -6,6 +6,19 @@
#include "bgfx_p.h"
#if BGFX_CONFIG_RENDERER_DIRECT3D12
namespace bgfx
{
RendererContextI* rendererCreateD3D12()
{
return NULL;
}
void rendererDestroyD3D12()
{
}
} // namespace bgfx
#else
namespace bgfx