STDMETHODIMP OnStatusChanged(REFIID report_type, LOCATION_REPORT_STATUS new_status)
{
UNREF_PARAM(report_type);
UNREF_PARAM(new_status);
return S_OK;
}
void OGLESRenderWindow::WindowMovedOrResized(Window const & win)
{
#if defined KLAYGE_PLATFORM_WINDOWS
UNREF_PARAM(win);
::RECT rect;
::GetClientRect(hWnd_, &rect);
uint32_t new_left = rect.left;
uint32_t new_top = rect.top;
if ((new_left != left_) || (new_top != top_))
{
this->Reposition(new_left, new_top);
}
uint32_t new_width = rect.right - rect.left;
uint32_t new_height = rect.bottom - rect.top;
#elif defined KLAYGE_PLATFORM_LINUX
int screen = DefaultScreen(x_display_);
uint32_t new_width = DisplayWidth(x_display_, screen);
uint32_t new_height = DisplayHeight(x_display_, screen);
#elif defined KLAYGE_PLATFORM_ANDROID
// TODO: Is it correct?
uint32_t new_left = win.Left() / 2;
uint32_t new_top = win.Top() / 2;
if ((new_left != left_) || (new_top != top_))
{
this->Reposition(new_left, new_top);
}
EGLint w, h;
eglQuerySurface(display_, surf_, EGL_WIDTH, &w);
eglQuerySurface(display_, surf_, EGL_HEIGHT, &h);
uint32_t new_width = w - new_left;
uint32_t new_height = h - new_top;
#elif defined KLAYGE_PLATFORM_DARWIN
UNREF_PARAM(win);
uint2 screen = Context::Instance().AppInstance().MainWnd()->GetNSViewSize();
uint32_t new_width = screen[0];
uint32_t new_height = screen[1];
#elif defined KLAYGE_PLATFORM_IOS
UNREF_PARAM(win);
uint2 screen = Context::Instance().AppInstance().MainWnd()->GetGLKViewSize();
uint32_t new_width = screen[0];
uint32_t new_height = screen[1];
#endif
if ((new_width != width_) || (new_height != height_))
{
Context::Instance().RenderFactoryInstance().RenderEngineInstance().Resize(new_width, new_height);
}
}
ID3D11UnorderedAccessViewPtr const & D3D11Texture3D::RetriveD3DUnorderedAccessView(uint32_t first_array_index, uint32_t num_items, uint32_t level)
{
BOOST_ASSERT(this->AccessHint() & EAH_GPU_Unordered);
BOOST_ASSERT(0 == first_array_index);
BOOST_ASSERT(1 == num_items);
UNREF_PARAM(first_array_index);
UNREF_PARAM(num_items);
D3D11_UNORDERED_ACCESS_VIEW_DESC desc;
memset(&desc, 0, sizeof(desc));
desc.Format = desc_.Format;
desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE3D;
desc.Texture3D.MipSlice = level;
return this->RetriveD3DUAV(desc);
}
uint32_t OGLESTexture::Depth(uint32_t level) const
{
UNREF_PARAM(level);
BOOST_ASSERT(level < num_mip_maps_);
return 1;
}
void OGLESTexture3DRenderView::OnDetached(FrameBuffer& fb, uint32_t att)
{
UNREF_PARAM(fb);
BOOST_ASSERT(att != FrameBuffer::ATT_DepthStencil);
BOOST_ASSERT(fbo_ == checked_cast<OGLESFrameBuffer*>(&fb)->OGLFbo());
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindFramebuffer(fbo_);
BOOST_ASSERT(copy_to_tex_ != 0);
if (1 == copy_to_tex_)
{
glFramebufferTexture3DOES(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0 + att - FrameBuffer::ATT_Color0,
GL_TEXTURE_3D_OES, 0, 0, 0);
}
else
{
BOOST_ASSERT(2 == copy_to_tex_);
glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0 + att - FrameBuffer::ATT_Color0,
GL_TEXTURE_2D, 0, 0);
this->CopyToSlice(att);
}
re.BindFramebuffer(0);
}
void OGLESTextureCubeDepthStencilRenderView::OnAttached(FrameBuffer& fb, uint32_t att)
{
UNREF_PARAM(att);
BOOST_ASSERT(FrameBuffer::ATT_DepthStencil == att);
index_ = 0;
fbo_ = checked_cast<OGLESFrameBuffer*>(&fb)->OGLFbo();
GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X + face_ - Texture::CF_Positive_X;
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindFramebuffer(fbo_);
if (IsDepthFormat(pf_))
{
glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_DEPTH_ATTACHMENT, face, tex_, level_);
}
if (IsStencilFormat(pf_))
{
glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_STENCIL_ATTACHMENT, face, tex_, level_);
}
re.BindFramebuffer(0);
}
SceneObjectHelper::SceneObjectHelper(std::function<RenderablePtr()> const & renderable_rl, uint32_t attrib, int dummy)
: SceneObject(attrib)
{
UNREF_PARAM(dummy);
renderable_rl_ = renderable_rl;
}
uint32_t D3D11Texture::Height(uint32_t level) const
{
UNREF_PARAM(level);
BOOST_ASSERT(level < num_mip_maps_);
return 1;
}
void removeUIManagerInterface(Renderer* pRenderer, UIManager* pUIManager)
{
UNREF_PARAM(pRenderer);
pUIManager->pUIRenderer->~UIRenderer();
conf_free(pUIManager->pUIRenderer);
conf_free(pUIManager);
}
void TgtProcessIntf::processError(QProcess::ProcessError error)
{
#ifdef QT_DEBUG
qDebug("Error %i", error);
#else
UNREF_PARAM(error);
#endif
}
void OGLESScreenDepthStencilRenderView::OnDetached(FrameBuffer& fb, uint32_t /*att*/)
{
UNREF_PARAM(fb);
BOOST_ASSERT(0 == checked_cast<OGLESFrameBuffer*>(&fb)->OGLFbo());
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindFramebuffer(0);
}
void cmdUIDrawTexturedQuad(struct Cmd* pCmd, UIManager* pUIManager, const vec2& position, const vec2& size, Texture* pTexture)
{
UNREF_PARAM(pCmd);
// the last variable can be used to create a border
TexVertex pVertices[] = { MAKETEXQUAD(position.getX(), position.getY(), position.getX() + size.getX(), position.getY() + size.getY(), 0) };
int nVertices = sizeof(pVertices) / sizeof(pVertices[0]);
float4 color = { 1.0f, 1.0f, 1.0f, 1.0f };
pUIManager->pUIRenderer->drawTextured(PRIMITIVE_TOPO_TRI_STRIP, pVertices, nVertices, pTexture, &color);
}
void OGLESDepthStencilRenderView::OnDetached(FrameBuffer& fb, uint32_t att)
{
UNREF_PARAM(fb);
UNREF_PARAM(att);
BOOST_ASSERT(FrameBuffer::ATT_DepthStencil == att);
BOOST_ASSERT(fbo_ == checked_cast<OGLESFrameBuffer*>(&fb)->OGLFbo());
if (level_ < 0)
{
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindFramebuffer(fbo_);
glFramebufferRenderbuffer(GL_FRAMEBUFFER,
GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER,
GL_STENCIL_ATTACHMENT,
GL_RENDERBUFFER, 0);
re.BindFramebuffer(0);
}
else
{
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
BOOST_ASSERT(GL_TEXTURE_2D == target_type_);
re.BindFramebuffer(fbo_);
if (IsDepthFormat(pf_))
{
glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_DEPTH_ATTACHMENT, target_type_, 0, 0);
}
if (IsStencilFormat(pf_))
{
glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_STENCIL_ATTACHMENT, target_type_, 0, 0);
}
re.BindFramebuffer(0);
}
}
void OGLESRenderEngine::CheckConfig(RenderSettings& settings)
{
#if defined KLAYGE_PLATFORM_ANDROID
settings.hdr = false;
settings.ppaa = false;
settings.gamma = false;
settings.color_grading = false;
#else
UNREF_PARAM(settings);
#endif
}
void
_interpreter::evaluate_assignment(
__in node_factory_ptr node_fact,
__in token_factory_ptr tok_fact,
__in node &node,
__in token &tok
)
{
TRACE_ENTRY();
SERIALIZE_CALL_RECUR(m_lock);
// TODO: evaluate_assignment
UNREF_PARAM(node_fact);
UNREF_PARAM(tok_fact);
UNREF_PARAM(node);
UNREF_PARAM(tok);
// ---
TRACE_EXIT("Return Value: 0x%x", NULL);
}
void OGLESScreenColorRenderView::OnAttached(FrameBuffer& fb, uint32_t att)
{
UNREF_PARAM(fb);
BOOST_ASSERT(0 == checked_cast<OGLESFrameBuffer*>(&fb)->OGLFbo());
index_ = att - FrameBuffer::ATT_Color0;
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindFramebuffer(0);
}
void cmdUIDrawText(struct Cmd* pCmd, UIManager* pUIManager, const vec2& position, const char* pText, const TextDrawDesc* pTextDrawDesc /*= NULL*/)
{
UNREF_PARAM(pCmd);
const TextDrawDesc* drawDesc = pTextDrawDesc ? pTextDrawDesc : &pUIManager->mSettings.mDefaultTextDrawDesc;
//Fontstash* pFont = pUIManager->pUIRenderer->getFontstash(drawDesc->mFontID);
Fontstash* pFont = pUIManager->pUIRenderer->getFontstash(0);
ASSERT(pFont);
pFont->drawText(pText, position.getX(), position.getY(), drawDesc->mFontID, drawDesc->mFontColor, drawDesc->mFontSize, drawDesc->mFontSpacing, drawDesc->mFontBlur);
}
void OGLESTextureCube::UnmapCube(uint32_t array_index, CubeFaces face, uint32_t level)
{
BOOST_ASSERT(0 == array_index);
UNREF_PARAM(array_index);
switch (last_tma_)
{
case TMA_Read_Only:
break;
case TMA_Write_Only:
case TMA_Read_Write:
{
GLint gl_internalFormat;
GLenum gl_format;
GLenum gl_type;
OGLESMapping::MappingFormat(gl_internalFormat, gl_format, gl_type, format_);
glBindTexture(target_type_, texture_);
if (IsCompressedFormat(format_))
{
int block_size;
if ((EF_BC1 == format_) || (EF_SIGNED_BC1 == format_) || (EF_BC1_SRGB == format_)
|| (EF_BC4 == format_) || (EF_SIGNED_BC4 == format_) || (EF_BC4_SRGB == format_))
{
block_size = 8;
}
else
{
block_size = 16;
}
GLsizei const image_size = ((this->Width(level) + 3) / 4) * ((this->Height(level) + 3) / 4) * block_size;
glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level,
0, 0, widths_[level], widths_[level], gl_format, image_size, &tex_data_[face * num_mip_maps_ + level][0]);
}
else
{
glTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level,
0, 0, widths_[level], widths_[level],
gl_format, gl_type, &tex_data_[face * num_mip_maps_ + level][0]);
}
}
break;
default:
BOOST_ASSERT(false);
break;
}
}
void OGLESTexture2DRenderView::OnDetached(FrameBuffer& fb, uint32_t att)
{
UNREF_PARAM(fb);
BOOST_ASSERT(att != FrameBuffer::ATT_DepthStencil);
BOOST_ASSERT(fbo_ == checked_cast<OGLESFrameBuffer*>(&fb)->OGLFbo());
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindFramebuffer(fbo_);
glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0 + att - FrameBuffer::ATT_Color0, texture_2d_.GLType(), 0, 0);
re.BindFramebuffer(0);
}
ID3D11UnorderedAccessViewPtr const & D3D11Texture3D::RetriveD3DUnorderedAccessView(uint32_t array_index, uint32_t first_slice, uint32_t num_slices, uint32_t level)
{
BOOST_ASSERT(0 == array_index);
UNREF_PARAM(array_index);
D3D11_UNORDERED_ACCESS_VIEW_DESC desc;
memset(&desc, 0, sizeof(desc));
desc.Format = desc_.Format;
desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE3D;
desc.Texture3D.MipSlice = level;
desc.Texture3D.FirstWSlice = first_slice;
desc.Texture3D.WSize = num_slices;
return this->RetriveD3DUAV(desc);
}
void OGLESTexture3DRenderView::CopyToSlice(uint32_t att)
{
BOOST_ASSERT(att != FrameBuffer::ATT_DepthStencil);
UNREF_PARAM(att);
if (glloader_GLES_VERSION_3_0())
{
glBindTexture(GL_TEXTURE_3D, tex_);
glCopyTexSubImage3D(GL_TEXTURE_3D, level_, 0, 0, slice_, 0, 0, width_, height_);
}
else
{
glBindTexture(GL_TEXTURE_3D_OES, tex_);
glCopyTexSubImage3DOES(GL_TEXTURE_3D_OES, level_, 0, 0, slice_, 0, 0, width_, height_);
}
}
ID3D11RenderTargetViewPtr const & D3D11Texture3D::RetriveD3DRenderTargetView(uint32_t array_index, uint32_t first_slice, uint32_t num_slices, uint32_t level)
{
BOOST_ASSERT(this->AccessHint() & EAH_GPU_Write);
BOOST_ASSERT(0 == array_index);
UNREF_PARAM(array_index);
D3D11_RENDER_TARGET_VIEW_DESC desc;
memset(&desc, 0, sizeof(desc));
desc.Format = D3D11Mapping::MappingFormat(this->Format());
desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D;
desc.Texture3D.MipSlice = level;
desc.Texture3D.FirstWSlice = first_slice;
desc.Texture3D.WSize = num_slices;
return this->RetriveD3DRTV(desc);
}
void OGLESTextureCubeRenderView::OnDetached(FrameBuffer& fb, uint32_t att)
{
UNREF_PARAM(fb);
BOOST_ASSERT(att != FrameBuffer::ATT_DepthStencil);
BOOST_ASSERT(fbo_ == checked_cast<OGLESFrameBuffer*>(&fb)->OGLFbo());
OGLESRenderEngine& re = *checked_cast<OGLESRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
re.BindFramebuffer(fbo_);
GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X + face_ - Texture::CF_Positive_X;
glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0 + att - FrameBuffer::ATT_Color0,
face, 0, 0);
re.BindFramebuffer(0);
}
void OGLESRenderWindow::WindowMovedOrResized(Window const & win)
{
#if defined KLAYGE_PLATFORM_WINDOWS
UNREF_PARAM(win);
::RECT rect;
::GetClientRect(hWnd_, &rect);
uint32_t new_left = rect.left;
uint32_t new_top = rect.top;
if ((new_left != left_) || (new_top != top_))
{
this->Reposition(new_left, new_top);
}
uint32_t new_width = rect.right - rect.left;
uint32_t new_height = rect.bottom - rect.top;
#elif defined KLAYGE_PLATFORM_LINUX
int screen = DefaultScreen(x_display_);
uint32_t new_width = DisplayWidth(x_display_, screen);
uint32_t new_height = DisplayHeight(x_display_, screen);
#elif defined KLAYGE_PLATFORM_ANDROID
uint32_t new_left = win.Left() / 2;
uint32_t new_top = win.Top() / 2;
if ((new_left != left_) || (new_top != top_))
{
this->Reposition(new_left, new_top);
}
EGLint new_width, new_height;
eglQuerySurface(display_, surf_, EGL_WIDTH, &new_width);
eglQuerySurface(display_, surf_, EGL_HEIGHT, &new_height);
new_width -= new_left;
new_height -= new_top;
#endif
if ((new_width != width_) || (new_height != height_))
{
Context::Instance().RenderFactoryInstance().RenderEngineInstance().Resize(new_width, new_height);
}
}
OGLESTextureCubeRenderView::OGLESTextureCubeRenderView(Texture& texture_cube, int array_index, Texture::CubeFaces face, int level)
: texture_cube_(*checked_cast<OGLESTextureCube*>(&texture_cube)),
face_(face), level_(level)
{
UNREF_PARAM(array_index);
BOOST_ASSERT(Texture::TT_Cube == texture_cube.Type());
BOOST_ASSERT(0 == array_index);
uint32_t const channels = NumComponents(texture_cube.Format());
if (((1 == channels) || (2 == channels)) && (!(glloader_GLES_VERSION_3_0() || glloader_GLES_EXT_texture_rg())))
{
THR(errc::function_not_supported);
}
tex_ = texture_cube_.GLTexture();
width_ = texture_cube_.Width(level);
height_ = texture_cube_.Height(level);
pf_ = texture_cube_.Format();
}
void OGLESTextureCube::MapCube(uint32_t array_index, CubeFaces face, uint32_t level, TextureMapAccess tma,
uint32_t x_offset, uint32_t y_offset, uint32_t /*width*/, uint32_t /*height*/,
void*& data, uint32_t& row_pitch)
{
BOOST_ASSERT(0 == array_index);
UNREF_PARAM(array_index);
last_tma_ = tma;
uint32_t const texel_size = NumFormatBytes(format_);
int block_size;
if (IsCompressedFormat(format_))
{
if ((EF_BC1 == format_) || (EF_SIGNED_BC1 == format_) || (EF_BC1_SRGB == format_)
|| (EF_BC4 == format_) || (EF_SIGNED_BC4 == format_) || (EF_BC4_SRGB == format_))
{
block_size = 8;
}
else
{
block_size = 16;
}
}
else
{
block_size = 0;
}
row_pitch = widths_[level] * texel_size;
uint8_t* p = &tex_data_[face * num_mip_maps_ + level][0];
if (IsCompressedFormat(format_))
{
data = p + (y_offset / 4) * row_pitch + (x_offset / 4 * block_size);
}
else
{
data = p + (y_offset * widths_[level] + x_offset) * texel_size;
}
}
OGLESTexture3DRenderView::OGLESTexture3DRenderView(Texture& texture_3d, int array_index, uint32_t slice, int level)
: texture_3d_(*checked_cast<OGLESTexture3D*>(&texture_3d)),
slice_(slice), level_(level), copy_to_tex_(0)
{
UNREF_PARAM(array_index);
BOOST_ASSERT(Texture::TT_3D == texture_3d.Type());
BOOST_ASSERT(texture_3d_.Depth(level) > slice);
BOOST_ASSERT(0 == array_index);
uint32_t const channels = NumComponents(texture_3d.Format());
if (((1 == channels) || (2 == channels)) && (!(glloader_GLES_VERSION_3_0() || glloader_GLES_EXT_texture_rg())))
{
THR(errc::function_not_supported);
}
tex_ = texture_3d_.GLTexture();
width_ = texture_3d_.Width(level);
height_ = texture_3d_.Height(level);
pf_ = texture_3d_.Format();
}
ID3D11DepthStencilViewPtr const & D3D11Texture3D::RetriveD3DDepthStencilView(uint32_t array_index, uint32_t first_slice, uint32_t num_slices, uint32_t level)
{
BOOST_ASSERT(this->AccessHint() & EAH_GPU_Write);
BOOST_ASSERT(0 == array_index);
UNREF_PARAM(array_index);
D3D11_DEPTH_STENCIL_VIEW_DESC desc;
memset(&desc, 0, sizeof(desc));
desc.Format = D3D11Mapping::MappingFormat(this->Format());
desc.Flags = 0;
if (this->SampleCount() > 1)
{
desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY;
}
else
{
desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
}
desc.Texture2DArray.MipSlice = level;
desc.Texture2DArray.ArraySize = num_slices;
desc.Texture2DArray.FirstArraySlice = first_slice;
return this->RetriveD3DDSV(desc);
}
// Create the Dir, support nesting path.
// if bRemoveFileSpec = TRUE, Removes the trailing file name and backslash from a path.
U32 CFileOps_i::MakeDir(LPCTSTR pszDir, bool bRemoveFileSpec)
{
TCHAR *endptr = NULL, *ptr = NULL, *slash = NULL, *pStrDir = NULL;
TCHAR szDir[MAX_PATH];
szDir[0] = _T('\0');
int len = strlen(pszDir);
if(len >= MAX_PATH)
{
StrNCpy(szDir, pszDir, MAX_PATH);
PathFormatEx(szDir, szDir);
}
else
{
PathFormatEx(pszDir, szDir); // PathRemoveBackslash
}
if(bRemoveFileSpec)
PathRemoveFileSpec(szDir);
pStrDir = szDir;
// Try to make the directory.
if (CreateDirectory(pStrDir, NULL) == TRUE)
{
return (DWORD)0;
}
else if(GetLastError() == ERROR_FILE_EXISTS)
{
return ERROR_FILE_EXISTS;
}
else
{
DWORD dwErr = GetLastError() ;
UNREF_PARAM(dwErr);
}
endptr = CStringUtl::strrchr(pStrDir, _T('\0'));
slash = CStringUtl::strrchr(pStrDir, _T('\\'));
// Search upward for the non-existing parent.
while (slash != NULL)
{
ptr = slash;
*ptr = _T('\0');
// If reached an existing parent, break.
if (PathFileExists(pStrDir) == TRUE)
break;
// If non-existing parent
else
{
slash = CStringUtl::strrchr(pStrDir, _T('\\'));
// If under / or current directory, make it.
if (slash == NULL || slash == pStrDir)
{
if ((CreateDirectory(pStrDir, NULL) != TRUE) && (GetLastError() != ERROR_FILE_EXISTS))
{
return (DWORD)(ERR_WIN32_ERROR_I);
}
}
}
}
// Create directories starting from upmost non-existing parent.
while (((ptr = CStringUtl::strchr(pStrDir, _T('\0'))) != endptr) && ptr)
{
*ptr = _T('\\');
if ((CreateDirectory(pStrDir, NULL) != TRUE) && (GetLastError() != ERROR_FILE_EXISTS))
{
return (DWORD)(ERR_WIN32_ERROR_I);
}
}
return (0);
}
// 设置是否是全屏状态
/////////////////////////////////////////////////////////////////////////////////
void D3D11RenderWindow::FullScreen(bool fs)
{
#ifdef KLAYGE_PLATFORM_WINDOWS_DESKTOP
if (isFullScreen_ != fs)
{
left_ = 0;
top_ = 0;
uint32_t style;
if (fs)
{
style = WS_POPUP;
}
else
{
style = WS_OVERLAPPEDWINDOW;
}
::SetWindowLongPtrW(hWnd_, GWL_STYLE, style);
RECT rc = { 0, 0, static_cast<LONG>(width_), static_cast<LONG>(height_) };
::AdjustWindowRect(&rc, style, false);
width_ = rc.right - rc.left;
height_ = rc.bottom - rc.top;
::SetWindowPos(hWnd_, nullptr, left_, top_, width_, height_, SWP_NOZORDER);
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
if (dxgi_sub_ver_ >= 2)
{
sc_desc1_.Width = width_;
sc_desc1_.Height = height_;
sc_fs_desc_.Windowed = !fs;
}
else
#endif
{
sc_desc_.BufferDesc.Width = width_;
sc_desc_.BufferDesc.Height = height_;
sc_desc_.Windowed = !fs;
}
isFullScreen_ = fs;
swap_chain_->SetFullscreenState(isFullScreen_, nullptr);
if (isFullScreen_)
{
DXGI_MODE_DESC desc;
std::memset(&desc, 0, sizeof(desc));
desc.Width = width_;
desc.Height = height_;
desc.Format = back_buffer_format_;
desc.RefreshRate.Numerator = 60;
desc.RefreshRate.Denominator = 1;
swap_chain_->ResizeTarget(&desc);
}
::ShowWindow(hWnd_, SW_SHOWNORMAL);
::UpdateWindow(hWnd_);
}
#else
UNREF_PARAM(fs);
#endif
}