bool gl_load(HDC deviceContext)
{
if (flextInit() == GL_FALSE)
return false;
if (wgl_LoadFunctions(deviceContext) == wgl_LOAD_FAILED)
return false;
return true;
}
void initEntryPoints(HWND hwnd, const PIXELFORMATDESCRIPTOR &pfd){
HDC hdc = GetDC(hwnd);
int nPixelFormat = ChoosePixelFormat(hdc, &pfd);
SetPixelFormat(hdc, nPixelFormat, &pfd);
HGLRC hglrc = wglCreateContext(hdc);
wglMakeCurrent(hdc, hglrc);
ogl_LoadFunctions();
wgl_LoadFunctions(hdc);
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hglrc);
ReleaseDC(hwnd, hdc);
}
static bool gl_init_extensions(HDC hdc)
{
if (!wgl_LoadFunctions(hdc)) {
blog(LOG_ERROR, "Failed to load WGL entry functions.");
return false;
}
if (!wgl_ext_ARB_pixel_format) {
required_extension_error("ARB_pixel_format");
return false;
}
if (!wgl_ext_ARB_create_context) {
required_extension_error("ARB_create_context");
return false;
}
if (!wgl_ext_ARB_create_context_profile) {
required_extension_error("ARB_create_context_profile");
return false;
}
return true;
}
void screen_init(struct rdp_config* config)
{
// make window resizable for the user
if (!fullscreen) {
LONG style = GetWindowLong(gfx.hWnd, GWL_STYLE);
style |= WS_SIZEBOX | WS_MAXIMIZEBOX;
SetWindowLong(gfx.hWnd, GWL_STYLE, style);
BOOL zoomed = IsZoomed(gfx.hWnd);
if (zoomed) {
ShowWindow(gfx.hWnd, SW_RESTORE);
}
// Fix client size after changing the window style, otherwise the PJ64
// menu will be displayed incorrectly.
// For some reason, this needs to be called twice, probably because the
// style set above isn't applied immediately.
for (int i = 0; i < 2; i++) {
win32_client_resize(gfx.hWnd, gfx.hStatusBar, WINDOW_DEFAULT_WIDTH, WINDOW_DEFAULT_HEIGHT);
}
if (zoomed) {
ShowWindow(gfx.hWnd, SW_MAXIMIZE);
}
}
PIXELFORMATDESCRIPTOR win_pfd = {
sizeof(PIXELFORMATDESCRIPTOR), 1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, // Flags
PFD_TYPE_RGBA, // The kind of framebuffer. RGBA or palette.
32, // Colordepth of the framebuffer.
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
24, // Number of bits for the depthbuffer
8, // Number of bits for the stencilbuffer
0, // Number of Aux buffers in the framebuffer.
PFD_MAIN_PLANE, 0, 0, 0, 0
};
dc = GetDC(gfx.hWnd);
if (!dc) {
msg_error("Can't get device context.");
}
int32_t win_pf = ChoosePixelFormat(dc, &win_pfd);
if (!win_pf) {
msg_error("Can't choose pixel format.");
}
SetPixelFormat(dc, win_pf, &win_pfd);
// create legacy context, required for wglGetProcAddress to work properly
glrc = wglCreateContext(dc);
if (!glrc || !wglMakeCurrent(dc, glrc)) {
msg_error("Can't create OpenGL context.");
}
// load wgl extension
wgl_LoadFunctions(dc);
// attributes for a 3.3 core profile without all the legacy stuff
GLint attribs[] = {
WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
WGL_CONTEXT_MINOR_VERSION_ARB, 3,
WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
0
};
// create the actual context
glrc_core = wglCreateContextAttribsARB(dc, glrc, attribs);
if (!glrc_core || !wglMakeCurrent(dc, glrc_core)) {
// rendering probably still works with the legacy context, so just send
// a warning
msg_warning("Can't create OpenGL 3.3 core context.");
}
// enable vsync
wglSwapIntervalEXT(1);
gl_screen_init(config);
}
bool OpenGLApp::initAPI(){
if (screen >= GetSystemMetrics(SM_CMONITORS)) screen = 0;
int monitorCounter = screen;
EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (LPARAM) &monitorCounter);
// TODO: Use this when saving out position?
// HMONITOR hMonitor = MonitorFromWindow(m_handle->hWnd, MONITOR_DEFAULTTOPRIMARY);
DWORD flags = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
int x, y;
x = monInfo.rcMonitor.left;
y = monInfo.rcMonitor.top;
device.cb = sizeof(device);
//TODO: Monitor count is not equal to device count?
EnumDisplayDevices(NULL, 0/*screen*/, &device, 0);
DEVMODE dm, tdm;
memset(&dm, 0, sizeof(dm));
dm.dmSize = sizeof(dm);
dm.dmBitsPerPel = colorBits;
dm.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
dm.dmPelsWidth = fullscreenWidth;
dm.dmPelsHeight = fullscreenHeight;
dm.dmDisplayFrequency = 60;
// Find a suitable fullscreen format
int i = 0;
int targetHz = 85;
char str[128];
resolution->clear();
while (EnumDisplaySettings((const char *) device.DeviceName, i, &tdm)){
if (int(tdm.dmBitsPerPel) == colorBits && tdm.dmPelsWidth >= 640 && tdm.dmPelsHeight >= 480){
sprintf(str, "%dx%d", tdm.dmPelsWidth, tdm.dmPelsHeight);
int index = resolution->addItemUnique(str);
if (int(tdm.dmPelsWidth) == fullscreenWidth && int(tdm.dmPelsHeight) == fullscreenHeight){
if (abs(int(tdm.dmDisplayFrequency) - targetHz) < abs(int(dm.dmDisplayFrequency) - targetHz)){
dm = tdm;
}
resolution->selectItem(index);
}
}
i++;
}
if (fullscreen){
//TODO: Select correct monitor?
//dm.dmFields |= DM_POSITION ;
//dm.dmPosition.x = x;
//dm.dmPosition.y = y;
if (ChangeDisplaySettingsEx((const char *) device.DeviceName, &dm, NULL, CDS_FULLSCREEN, NULL) == DISP_CHANGE_SUCCESSFUL){
flags |= WS_POPUP;
captureMouse(!configDialog->isVisible());
} else {
ErrorMsg("Couldn't set fullscreen mode");
fullscreen = false;
}
}
sprintf(str, "%s (%dx%d)", getTitle(), width, height);
if (!fullscreen){
flags |= WS_OVERLAPPEDWINDOW;
RECT wRect;
wRect.left = 0;
wRect.right = width;
wRect.top = 0;
wRect.bottom = height;
AdjustWindowRect(&wRect, flags, FALSE);
width = min(wRect.right - wRect.left, monInfo.rcWork.right - monInfo.rcWork.left);
height = min(wRect.bottom - wRect.top, monInfo.rcWork.bottom - monInfo.rcWork.top);
x = (monInfo.rcWork.left + monInfo.rcWork.right - width ) / 2;
y = (monInfo.rcWork.top + monInfo.rcWork.bottom - height) / 2;
}
hwnd = CreateWindow("Humus", str, flags, x, y, width, height, HWND_DESKTOP, NULL, hInstance, NULL);
PIXELFORMATDESCRIPTOR pfd = {
sizeof (PIXELFORMATDESCRIPTOR), 1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA, colorBits,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
depthBits, stencilBits,
0, PFD_MAIN_PLANE, 0, 0, 0, 0
};
hdc = GetDC(hwnd);
int iAttribs[] = {
WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
WGL_RED_BITS_ARB, 8,
WGL_GREEN_BITS_ARB, 8,
WGL_BLUE_BITS_ARB, 8,
WGL_ALPHA_BITS_ARB, (colorBits > 24)? 8 : 0,
WGL_DEPTH_BITS_ARB, depthBits,
WGL_STENCIL_BITS_ARB, stencilBits,
0
};
int pixelFormats[256];
int bestFormat = 0;
int bestSamples = 0;
uint nPFormats;
if (wgl_ext_ARB_pixel_format && wglChoosePixelFormatARB(hdc, iAttribs, NULL, elementsOf(pixelFormats), pixelFormats, &nPFormats) && nPFormats > 0){
int minDiff = 0x7FFFFFFF;
int attrib = WGL_SAMPLES_ARB;
int samples;
// Find a multisample format as close as possible to the requested
for (uint i = 0; i < nPFormats; i++){
wglGetPixelFormatAttribivARB(hdc, pixelFormats[i], 0, 1, &attrib, &samples);
int diff = abs(antiAliasSamples - samples);
if (diff < minDiff){
minDiff = diff;
bestFormat = i;
bestSamples = samples;
}
}
} else {
pixelFormats[0] = ChoosePixelFormat(hdc, &pfd);
}
antiAliasSamples = bestSamples;
SetPixelFormat(hdc, pixelFormats[bestFormat], &pfd);
if(wgl_ext_ARB_create_context)
{
glContext = wglCreateContextAttribsARB(hdc, 0, 0);
}
else
{
glContext = wglCreateContext(hdc);
}
wglMakeCurrent(hdc, glContext);
ogl_LoadFunctions();
wgl_LoadFunctions(hdc);
if (wgl_ext_ARB_multisample && antiAliasSamples > 0){
glEnable(GL_MULTISAMPLE);
}
if (fullscreen) captureMouse(!configDialog->isVisible());
renderer = new OpenGLRenderer(hdc, glContext);
renderer->setViewport(width, height);
antiAlias->selectItem(antiAliasSamples / 2);
linearClamp = renderer->addSamplerState(LINEAR, CLAMP, CLAMP, CLAMP);
defaultFont = renderer->addFont("../Textures/Fonts/Future.dds", "../Textures/Fonts/Future.font", linearClamp);
blendSrcAlpha = renderer->addBlendState(SRC_ALPHA, ONE_MINUS_SRC_ALPHA);
noDepthTest = renderer->addDepthState(false, false);
noDepthWrite = renderer->addDepthState(true, false);
cullNone = renderer->addRasterizerState(CULL_NONE);
cullBack = renderer->addRasterizerState(CULL_BACK);
cullFront = renderer->addRasterizerState(CULL_FRONT);
return true;
}
