bool CWinEGLPlatformGeneric::CreateWindow()
{
if (m_display == EGL_NO_DISPLAY || m_config == NULL)
{
if (!InitializeDisplay())
return false;
}
if (m_surface != EGL_NO_SURFACE)
return true;
m_nativeWindow = getNativeWindow();
m_surface = eglCreateWindowSurface(m_display, m_config, m_nativeWindow, NULL);
if (!m_surface)
{
CLog::Log(LOGERROR, "EGL couldn't create window surface");
return false;
}
// Let's get the current width and height
EGLint width, height;
if (!eglQuerySurface(m_display, m_surface, EGL_WIDTH, &width) || !eglQuerySurface(m_display, m_surface, EGL_HEIGHT, &height) ||
width <= 0 || height <= 0)
{
CLog::Log(LOGERROR, "EGL couldn't provide the surface's width and/or height");
return false;
}
m_width = width;
m_height = height;
return true;
}
EGLNativeWindowType CWinEGLPlatformGeneric::InitWindowSystem(EGLNativeDisplayType nativeDisplay, int width, int height, int bpp)
{
m_nativeDisplay = nativeDisplay;
m_width = width;
m_height = height;
return getNativeWindow();
}
EGLNativeWindowType CWinEGLPlatformAndroid::InitWindowSystem(EGLNativeDisplayType nativeDisplay, int width, int height, int bpp)
{
if (CPlatformUtils::GetPlatform() == NULL || CPlatformUtils::GetPlatform()->window == NULL)
return 0;
CWinEGLPlatformGeneric::InitWindowSystem(nativeDisplay, width, height, bpp);
return getNativeWindow();
}
AppCtx* initApp()
{
AppCtx *appCtx= 0;
appCtx= (AppCtx*)calloc( 1, sizeof(AppCtx) );
if ( appCtx )
{
#if defined (WESTEROS_PLATFORM_EMBEDDED)
appCtx->inputCtx= (InputCtx*)calloc( 1, sizeof(InputCtx) );
if ( !appCtx->inputCtx )
{
free( appCtx );
appCtx= 0;
goto exit;
}
appCtx->inputCtx->started= false;
appCtx->inputCtx->stopRequested= false;
#else
int argc= 0;
char **argv= 0;
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA );
glutInitWindowPosition(0,0);
glutInitWindowSize(1280, 720);
sprintf( appCtx->title, "Westeros-%d", getpid() );
appCtx->glutWindowId= glutCreateWindow(appCtx->title);
g_appCtxMap.insert( std::pair<int,AppCtx*>( appCtx->glutWindowId, appCtx ) );
glutSetOption(GLUT_RENDERING_CONTEXT, GLUT_USE_CURRENT_CONTEXT);
glewInit();
glutWMCloseFunc( onGlutClose );
glutDisplayFunc( onGlutDisplay );
glutReshapeFunc( onGlutReshape );
glutMotionFunc( onGlutMotion );
glutPassiveMotionFunc( onGlutMotion );
glutMouseFunc(onGlutMouse);
glutKeyboardFunc( onGlutKeyboard );
glutSpecialFunc( onGlutSpecial );
glClearColor( 0, 0, 0, 1 );
appCtx->nativeWindow= getNativeWindow( appCtx );
printf("nativeWindow= %p\n", appCtx->nativeWindow );
#endif
}
exit:
return appCtx;
}
VKTS_NATIVE_WINDOW UpdateThreadContext::getNativeWindow(const int32_t windowIndex) const
{
static VKTS_NATIVE_WINDOW noWindow;
auto currentWindow = getWindow(windowIndex);
if (currentWindow.get())
{
return currentWindow->getNativeWindow();
}
return noWindow;
}
void RiftRenderingApp::initializeRiftRendering() {
ovrGLConfig cfg;
memset(&cfg, 0, sizeof(cfg));
cfg.OGL.Header.API = ovrRenderAPI_OpenGL;
cfg.OGL.Header.BackBufferSize = ovr::fromGlm(hmdNativeResolution);
cfg.OGL.Header.Multisample = 1;
ON_WINDOWS([&]{
cfg.OGL.Window = (HWND)getNativeWindow();
});
int distortionCaps = 0
| ovrDistortionCap_Vignette
| ovrDistortionCap_Overdrive
| ovrDistortionCap_TimeWarp;
ON_LINUX([&]{
distortionCaps |= ovrDistortionCap_LinuxDevFullscreen;
});
ovrEyeRenderDesc eyeRenderDescs[2];
int configResult = ovrHmd_ConfigureRendering(hmd, &cfg.Config,
distortionCaps, hmd->MaxEyeFov, eyeRenderDescs);
assert(configResult);
for_each_eye([&](ovrEyeType eye){
const ovrEyeRenderDesc & erd = eyeRenderDescs[eye];
ovrMatrix4f ovrPerspectiveProjection = ovrMatrix4f_Projection(erd.Fov, 0.01f, 100000.0f, true);
projections[eye] = ovr::toGlm(ovrPerspectiveProjection);
eyeOffsets[eye] = erd.HmdToEyeViewOffset;
});
// Allocate the frameBuffer that will hold the scene, and then be
// re-rendered to the screen with distortion
glm::uvec2 frameBufferSize = ovr::toGlm(eyeTextures[0].Header.TextureSize);
for_each_eye([&](ovrEyeType eye) {
eyeFramebuffers[eye] = FramebufferWrapperPtr(new FramebufferWrapper());
eyeFramebuffers[eye]->init(frameBufferSize);
((ovrGLTexture&)(eyeTextures[eye])).OGL.TexId =
oglplus::GetName(eyeFramebuffers[eye]->color);
});
}
HRESULT NativeWindow11Win32::createSwapChain(ID3D11Device *device,
IDXGIFactory *factory,
DXGI_FORMAT format,
UINT width,
UINT height,
IDXGISwapChain **swapChain)
{
if (device == NULL || factory == NULL || swapChain == NULL || width == 0 || height == 0)
{
return E_INVALIDARG;
}
if (mDirectComposition)
{
#ifdef HAS_DIRECT_COMPOSITION
HMODULE dcomp = ::GetModuleHandle(TEXT("dcomp.dll"));
if (!dcomp)
{
return E_INVALIDARG;
}
typedef HRESULT(WINAPI * PFN_DCOMPOSITION_CREATE_DEVICE)(
IDXGIDevice * dxgiDevice, REFIID iid, void **dcompositionDevice);
PFN_DCOMPOSITION_CREATE_DEVICE createDComp =
reinterpret_cast<PFN_DCOMPOSITION_CREATE_DEVICE>(
GetProcAddress(dcomp, "DCompositionCreateDevice"));
if (!createDComp)
{
return E_INVALIDARG;
}
if (!mDevice)
{
IDXGIDevice *dxgiDevice = d3d11::DynamicCastComObject<IDXGIDevice>(device);
HRESULT result = createDComp(dxgiDevice, __uuidof(IDCompositionDevice),
reinterpret_cast<void **>(&mDevice));
SafeRelease(dxgiDevice);
if (FAILED(result))
{
return result;
}
}
if (!mCompositionTarget)
{
HRESULT result =
mDevice->CreateTargetForHwnd(getNativeWindow(), TRUE, &mCompositionTarget);
if (FAILED(result))
{
return result;
}
}
if (!mVisual)
{
HRESULT result = mDevice->CreateVisual(&mVisual);
if (FAILED(result))
{
return result;
}
}
IDXGIFactory2 *factory2 = d3d11::DynamicCastComObject<IDXGIFactory2>(factory);
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
swapChainDesc.Width = width;
swapChainDesc.Height = height;
swapChainDesc.Format = format;
swapChainDesc.Stereo = FALSE;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.BufferUsage =
DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_BACK_BUFFER | DXGI_USAGE_SHADER_INPUT;
swapChainDesc.BufferCount = 2;
swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
swapChainDesc.AlphaMode =
mHasAlpha ? DXGI_ALPHA_MODE_PREMULTIPLIED : DXGI_ALPHA_MODE_IGNORE;
swapChainDesc.Flags = 0;
IDXGISwapChain1 *swapChain1 = nullptr;
HRESULT result =
factory2->CreateSwapChainForComposition(device, &swapChainDesc, nullptr, &swapChain1);
if (SUCCEEDED(result))
{
*swapChain = static_cast<IDXGISwapChain *>(swapChain1);
}
mVisual->SetContent(swapChain1);
mCompositionTarget->SetRoot(mVisual);
SafeRelease(factory2);
return result;
#else // HAS_DIRECT_COMPOSITION
return E_INVALIDARG;
#endif // HAS_DIRECT_COMPOSITION
}
// Use IDXGIFactory2::CreateSwapChainForHwnd if DXGI 1.2 is available to create a
// DXGI_SWAP_EFFECT_SEQUENTIAL swap chain.
IDXGIFactory2 *factory2 = d3d11::DynamicCastComObject<IDXGIFactory2>(factory);
if (factory2 != nullptr)
{
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
swapChainDesc.Width = width;
swapChainDesc.Height = height;
swapChainDesc.Format = format;
swapChainDesc.Stereo = FALSE;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.BufferUsage =
DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_BACK_BUFFER;
swapChainDesc.BufferCount = 1;
swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL;
swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED;
swapChainDesc.Flags = 0;
IDXGISwapChain1 *swapChain1 = nullptr;
HRESULT result = factory2->CreateSwapChainForHwnd(device, getNativeWindow(), &swapChainDesc,
nullptr, nullptr, &swapChain1);
if (SUCCEEDED(result))
{
factory2->MakeWindowAssociation(getNativeWindow(), DXGI_MWA_NO_ALT_ENTER);
*swapChain = static_cast<IDXGISwapChain *>(swapChain1);
}
SafeRelease(factory2);
return result;
}
DXGI_SWAP_CHAIN_DESC swapChainDesc = {};
swapChainDesc.BufferCount = 1;
swapChainDesc.BufferDesc.Format = format;
swapChainDesc.BufferDesc.Width = width;
swapChainDesc.BufferDesc.Height = height;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.RefreshRate.Numerator = 0;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1;
swapChainDesc.BufferUsage =
DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_BACK_BUFFER;
swapChainDesc.Flags = 0;
swapChainDesc.OutputWindow = getNativeWindow();
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.Windowed = TRUE;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
HRESULT result = factory->CreateSwapChain(device, &swapChainDesc, swapChain);
if (SUCCEEDED(result))
{
factory->MakeWindowAssociation(getNativeWindow(), DXGI_MWA_NO_ALT_ENTER);
}
return result;
}
bool NativeWindow11Win32::isIconic() const
{
return IsIconic(getNativeWindow()) == TRUE;
}
bool NativeWindow11Win32::getClientRect(LPRECT rect) const
{
return GetClientRect(getNativeWindow(), rect) == TRUE;
}
ShimEGLNativeWindowType ShimGetNativeWindow(ShimNativeWindowId window_id) {
auto surface = the_shim->getSurface(window_id);
LOG("ShimGetNativeWindow %ld (surface %p)\n", window_id, surface);
ANativeWindow *window = surface ? surface->getNativeWindow() : nullptr;
return reinterpret_cast<ShimEGLNativeWindowType>(window);
}
