/* general OpenGL initialization function */
int initGL()
{
if (!loadGLTextures())
{
return False;
}
glEnable(GL_TEXTURE_2D); /* Enable Texture Mapping */
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
/* set up our lighting */
glLightfv(GL_LIGHT1, GL_AMBIENT, lightAmbient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, lightDiffuse);
glLightfv(GL_LIGHT1, GL_POSITION, lightPosition);
glEnable(GL_LIGHT1);
/* we use resizeGLScene once to set up our initial perspective */
resizeGLScene(GLWin.width, GLWin.height);
if (light)
glEnable(GL_LIGHTING);
glFlush();
return True;
}
/* general OpenGL initialization function */
int initGL(GLvoid)
{
if (!loadGLTextures())
{
return False;
}
glEnable(GL_TEXTURE_2D); /* enable texture mapping */
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glColor4f(1.0f, 1.0f, 1.0f, 0.5f); /* full brightness, 50% Alpha */
glBlendFunc(GL_SRC_ALPHA, GL_ONE); /* blending function */
/* set up our lighting */
glLightfv(GL_LIGHT1, GL_AMBIENT, lightAmbient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, lightDiffuse);
glLightfv(GL_LIGHT1, GL_POSITION, lightPosition);
glEnable(GL_LIGHT1);
/* we use resizeGLScene once to set up our initial perspective */
resizeGLScene(GLWin.width, GLWin.height);
/* test the state of blending and lighting, so keep it when switching
* between fullscreen and window mode
*/
if (blend)
{
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
}
if (light)
glEnable(GL_LIGHTING);
glFlush();
return True;
}
void Game::initDisplay()
{
mainOpenGLState = new CL_OpenGLState(CL_Display::get_current_window()->get_gc());
mainOpenGLState->set_active();
resizeGLScene();
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0);
//ne dessine que les faces avant des polygones
glCullFace(GL_FRONT);
//active le depth buffer
glEnable(GL_DEPTH_TEST);
//normalize les vecteurs
glEnable(GL_NORMALIZE);
//dessine que les polygones definis dans le sens trigonometrique
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW);
//modele de degrade
glShadeModel(GL_SMOOTH);
//filtrage des textures
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//gestion des lumiéres
GLfloat ambient[] = {0.4f, 0.4f, 0.4f, 1.0f};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
#ifndef WIN32
//sépare la couleur spéculaire pour les textures
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
#endif
//lumiére de position, donc w = 1.0 (sinon lumiére directionnelle)
GLfloat position[] = {world->getWidth() / 2.0f - 2.0f, world->getHeight() / 2.0f - 2.0f, -world->getDepth() / 2.0f + 2.0f, 1.0f};
GLfloat direction[] = {-1.0, -1.0, 1.0};
GLfloat cutoff[] = {90.0f};
GLfloat attenuation[] = {0.2f};
GLfloat diffuse[] = {1.0, 1.0, 1.0, 1.0};
GLfloat specular[] = {1.0, 1.0, 1.0, 1.0};
glLightfv(GL_LIGHT0, GL_POSITION, position);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, direction);
glLightfv(GL_LIGHT0, GL_SPOT_CUTOFF, cutoff);
glLightfv(GL_LIGHT0, GL_CONSTANT_ATTENUATION, attenuation);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
world->initDisplay();
}
/* general OpenGL initialization function */
int initGL(GLvoid)
{
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
/* we use resizeGLScene once to set up our initial perspective */
resizeGLScene(GLWin.width, GLWin.height);
/* Reset the rotation angles of our objects */
rotTri = 0;
rotQuad = 0;
glFlush();
return True;
}
void initGL()
{
glEnable(GL_TEXTURE_2D); /* Enable Texture Mapping */
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
/* we use resizeGLScene once to set up our initial perspective */
resizeGLScene(640,480);
glFlush();
}
int initGL() /* All Setup For OpenGL Goes Here */
{
glEnable(GL_TEXTURE_2D); /* Enable Texture Mapping */
glShadeModel(GL_SMOOTH); /* Enable Smooth Shading */
glClearColor(0.05f, 0.05f, 0.05f, 0.5f); /* Black Background */
glClearDepth(1.0f); /* Depth Buffer Setup */
glEnable(GL_DEPTH_TEST); /* Enables Depth Testing */
glDepthFunc(GL_LEQUAL); /* The Type Of Depth Testing To Do */
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); /* Really Nice Perspective Calculations */
initBezier(); /* Initialize the Bezier's control grid */
LoadGLTexture(&(mybezier.texture), "./data/NeHe.bmp"); /* Load the texture */
mybezier.dlBPatch = genBezier(mybezier, divs); /* Generate the patch */
resizeGLScene(GLWin.width, GLWin.height);
glFlush();
return True; /* Initialization Went OK */
}
/* general OpenGL initialization function */
int initGL(GLvoid)
{
if (!loadGLTextures())
{
return False;
}
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture[0]);
/* initializing our particles */
for (loop = 0; loop < MAX_PARTICLES; loop++) {
particle[loop].active = True;
particle[loop].life = 1.0f;
particle[loop].fade = (float) (rand() % 100) / 1000 + 0.003f;
particle[loop].red = colors[loop / (MAX_PARTICLES / 12)][0];
particle[loop].green = colors[loop / (MAX_PARTICLES / 12)][0];
particle[loop].blue = colors[loop / (MAX_PARTICLES / 12)][0];
particle[loop].xSpeed = (float) ((rand() % 50) - 26.0f) * 10.0f;
particle[loop].ySpeed = (float) ((rand() % 50) - 25.0f) * 10.0f;
particle[loop].zSpeed = (float) ((rand() % 50) - 25.0f) * 10.0f;
particle[loop].xGrav = 0.0f;
particle[loop].yGrav = -0.8f;
particle[loop].zGrav = 0.0f;
}
/* we use resizeGLScene once to set up our initial perspective */
resizeGLScene(GLWin.width, GLWin.height);
glFlush();
return True;
}
BOOL OpenGLGame::createGLWindow()
{
GLuint PixelFormat; // 保存查找匹配的结果
WNDCLASS wc; // 窗口类结构
DWORD dwExStyle; // 扩展窗口风格
DWORD dwStyle; // 窗口风格
RECT WindowRect; // 取得矩形的左上角和右下角的坐标值
WindowRect.left = ( long )0; // 将Left 设为 0
WindowRect.right = ( long )m_nWidth; // 将Right 设为要求的宽度
WindowRect.top = ( long )0; // 将Top 设为 0
WindowRect.bottom = ( long )m_nHeight; // 将Bottom 设为要求的高度
m_hInstance = GetModuleHandle( NULL ); // 取得我们窗口的实例
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // 移动时重画，并为窗口取得DC
wc.lpfnWndProc = ( WNDPROC ) &OpenGLGame::wndProc; // WndProc处理消息
wc.cbClsExtra = 0; // 无额外窗口数据
wc.cbWndExtra = 0; // 无额外窗口数据
wc.hInstance = m_hInstance; // 设置实例
wc.hIcon = LoadIcon( NULL, IDI_WINLOGO ); // 装入缺省图标
wc.hCursor = LoadCursor( NULL, IDC_ARROW ); // 装入鼠标指针
wc.hbrBackground = NULL; // GL不需要背景
wc.lpszMenuName = NULL; // 不需要菜单
wc.lpszClassName = "OpenG"; // 设定类名字
if ( !RegisterClass( &wc ) ) // 尝试注册窗口类
{
MessageBox( NULL, "注册窗口失败", "错误", MB_OK | MB_ICONEXCLAMATION );
return FALSE; // 退出并返回FALSE
}
if ( m_bFullScreen ) // 要尝试全屏模式吗?
{
DEVMODE dmScreenSettings; // 设备模式
memset( &dmScreenSettings, 0, sizeof( dmScreenSettings ) ); // 确保内存清空为零
dmScreenSettings.dmSize = sizeof( dmScreenSettings ); // Devmode 结构的大小
dmScreenSettings.dmPelsWidth = m_nWidth; // 所选屏幕宽度
dmScreenSettings.dmPelsHeight = m_nHeight; // 所选屏幕高度
dmScreenSettings.dmBitsPerPel = m_nBitMode; // 每象素所选的色彩深度
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
// 尝试设置显示模式并返回结果。注: CDS_FULLSCREEN 移去了状态条。
if ( ChangeDisplaySettings( &dmScreenSettings, CDS_FULLSCREEN ) != DISP_CHANGE_SUCCESSFUL )
{
// 若模式失败，提供两个选项：退出或在窗口内运行。
if ( MessageBox( NULL, "全屏模式在当前显卡上设置失败！\n使用窗口模式？", "G", MB_YESNO | MB_ICONEXCLAMATION ) == IDYES )
{
m_bFullScreen = FALSE; // 选择窗口模式(Fullscreen=FALSE)
}
else
{
// 弹出一个对话框，告诉用户程序结束
MessageBox( NULL, "程序将被关闭", "错误", MB_OK | MB_ICONSTOP );
return FALSE; // 退出并返回 FALSE
}
}
}
if ( m_bFullScreen ) // 仍处于全屏模式吗?
{
dwExStyle = WS_EX_APPWINDOW; // 扩展窗体风格
dwStyle = WS_POPUP; // 窗体风格
ShowCursor( FALSE ); // 隐藏鼠标指针
}
else
{
dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // 扩展窗体风格
dwStyle = WS_OVERLAPPEDWINDOW; // 窗体风格
}
AdjustWindowRectEx( &WindowRect, dwStyle, FALSE, dwExStyle ); // 调整窗口达到真正要求的大小
if ( !( m_hWnd = CreateWindowEx( dwExStyle, // 扩展窗体风格
"OpenG", // 类名字
m_szTitle, // 窗口标题
WS_CLIPSIBLINGS | // 必须的窗体风格属性
WS_CLIPCHILDREN | // 必须的窗体风格属性
dwStyle, // 选择的窗体属性
0, 0, // 窗口位置
WindowRect.right - WindowRect.left, // 计算调整好的窗口宽度
WindowRect.bottom - WindowRect.top, // 计算调整好的窗口高度
NULL, // 无父窗口
NULL, // 无菜单
m_hInstance, // 实例
NULL ) ) ) // 不向WM_CREATE传递任何东东
{
killGLWindow(); // 重置显示区
MessageBox( NULL, "不能创建一个窗口设备描述表", "错误", MB_OK | MB_ICONEXCLAMATION );
return FALSE; // 返回 FALSE
}
static PIXELFORMATDESCRIPTOR pfd = // /pfd 告诉窗口我们所希望的东东，即窗口使用的像素格式
{
sizeof( PIXELFORMATDESCRIPTOR ), // 上述格式描述符的大小
1, // 版本号
PFD_DRAW_TO_WINDOW | // 格式支持窗口
PFD_SUPPORT_OPENGL | // 格式必须支持OpenGL
PFD_DOUBLEBUFFER, // 必须支持双缓冲
PFD_TYPE_RGBA, // 申请 RGBA 格式
m_nBitMode, // 选定色彩深度
0, 0, 0, 0, 0, 0, // 忽略的色彩位
0, // 无Alpha缓存
0, // 忽略Shift Bit
0, // 无累加缓存
0, 0, 0, 0, // 忽略聚集位
16, // 16位 Z-缓存 (深度缓存)
0, // 无蒙板缓存
0, // 无辅助缓存
PFD_MAIN_PLANE, // 主绘图层
0, // Reserved
0, 0, 0 // 忽略层遮罩
};
if ( !( m_hDC = GetDC( m_hWnd ) ) ) // 取得设备描述表了么?
{
killGLWindow(); // 重置显示区
MessageBox( NULL, "不能创建一种相匹配的像素格式", "错误", MB_OK | MB_ICONEXCLAMATION );
return FALSE; // 返回 FALSE
}
if ( !( PixelFormat = ChoosePixelFormat( m_hDC, &pfd ) ) ) // Windows 找到相应的象素格式了吗?
{
killGLWindow(); // 重置显示区
MessageBox( NULL, "不能设置像素格式", "错误", MB_OK | MB_ICONEXCLAMATION );
return FALSE; // 返回 FALSE
}
if( !SetPixelFormat( m_hDC, PixelFormat, &pfd ) ) // 能够设置象素格式么?
{
killGLWindow(); // 重置显示区
MessageBox( NULL, "不能设置像素格式", "错误", MB_OK | MB_ICONEXCLAMATION );
return FALSE; // 返回 FALSE
}
if ( !( m_hRC = wglCreateContext( m_hDC ) ) ) // 能否取得着色描述表?
{
killGLWindow(); // 重置显示区
MessageBox( NULL, "不能创建OpenGL渲染描述表", "错误", MB_OK | MB_ICONEXCLAMATION );
return FALSE; // 返回 FALSE
}
if( !wglMakeCurrent( m_hDC, m_hRC ) ) // 尝试激活着色描述表
{
killGLWindow(); // 重置显示区
MessageBox( NULL, "不能激活当前的OpenGL渲然描述表", "错误", MB_OK | MB_ICONEXCLAMATION );
return FALSE; // 返回 FALSE
}
ShowWindow( m_hWnd, SW_SHOW ); // 显示窗口
SetForegroundWindow( m_hWnd ); // 略略提高优先级
SetFocus( m_hWnd ); // 设置键盘的焦点至此窗口
resizeGLScene( m_nWidth, m_nHeight ); // 设置透视 GL 屏幕
if ( !initGL() ) // 初始化新建的GL窗口
{
killGLWindow(); // 重置显示区
MessageBox( NULL, "Initialization Failed.", "ERROR", MB_OK | MB_ICONEXCLAMATION );
return FALSE; // 返回 FALSE
}
return TRUE; // 成功
}
int main(int argc, char **argv)
{
XEvent event;
KeySym key;
done = False;
/* default to fullscreen */
GLWin.fs = True;
createGLWindow("NeHe's Rotation Tutorial", 1920, 1280, 24, GLWin.fs);
/* wait for events*/
while (!done)
{
/* handle the events in the queue */
while (XPending(GLWin.dpy) > 0)
{
XNextEvent(GLWin.dpy, &event);
switch (event.type)
{
case Expose:
if (event.xexpose.count != 0)
break;
drawGLScene();
break;
case ConfigureNotify:
/* call resizeGLScene only if our window-size changed */
if ((event.xconfigure.width != GLWin.width) ||
(event.xconfigure.height != GLWin.height))
{
GLWin.width = event.xconfigure.width;
GLWin.height = event.xconfigure.height;
printf("Resize event\n");
resizeGLScene(event.xconfigure.width,
event.xconfigure.height);
}
break;
/* exit in case of a mouse button press */
case ButtonPress:
done = True;
break;
case KeyPress:
key = XLookupKeysym(&event.xkey, 0);
keyPressed(key);
break;
case ClientMessage:
if (*XGetAtomName(GLWin.dpy, event.xclient.message_type) ==
*"WM_PROTOCOLS")
{
printf("Exiting sanely...\n");
done = True;
}
break;
default:
break;
}
}
drawGLScene();
}
killGLWindow();
return 0;
}
static void HandleMessage( PRENDERER gl_camera, GLWindow *x11_gl_window, XEvent *event)
{
switch( event->type )
{
case ButtonPress:
{
// event->xbutton.state - prior state before this event
// event->xbutton.button = which button is changed.
switch( event->xbutton.button )
{
case Button1:
x11_gl_window->mouse_b |= MK_LBUTTON;
break;
case Button2:
x11_gl_window->mouse_b |= MK_RBUTTON;
break;
case Button3:
x11_gl_window->mouse_b |= MK_MBUTTON;
break;
}
}
//lprintf( "Mouse down... %d %d %d", x11_gl_window->mouse_x,x11_gl_window->mouse_y,x11_gl_window->mouse_b );
InvokeMouseEvent( gl_camera, x11_gl_window );
break;
case ButtonRelease:
{
// event->xbutton.state - prior state before this event
// event->xbutton.button = which button is changed.
switch( event->xbutton.button )
{
case Button1:
x11_gl_window->mouse_b &= ~MK_LBUTTON;
break;
case Button2:
x11_gl_window->mouse_b &= ~MK_RBUTTON;
break;
case Button3:
x11_gl_window->mouse_b &= ~MK_MBUTTON;
break;
}
}
//lprintf( "Mouse up... %d %d %d", x11_gl_window->mouse_x,x11_gl_window->mouse_y,x11_gl_window->mouse_b );
InvokeMouseEvent( gl_camera, x11_gl_window );
break;
case MotionNotify:
x11_gl_window->mouse_x = event->xmotion.x;
x11_gl_window->mouse_y = event->xmotion.y;
//lprintf( "Mouse move... %d %d %d", x11_gl_window->mouse_x,x11_gl_window->mouse_y,x11_gl_window->mouse_b );
InvokeMouseEvent( gl_camera, x11_gl_window );
break;
case Expose:
if (event->xexpose.count != 0)
break;
//drawGLScene( camera, x11_gl_window );
break;
case ConfigureNotify:
/* call resizeGLScene only if our window-size changed */
if ((event->xconfigure.width != x11_gl_window->width) ||
(event->xconfigure.height != x11_gl_window->height))
{
x11_gl_window->width = event->xconfigure.width;
x11_gl_window->height = event->xconfigure.height;
resizeGLScene(event->xconfigure.width,
event->xconfigure.height);
}
break;
/* exit in case of a mouse button press */
case KeyPress:
{
int used = FALSE;
//char buffer[32];
//KeySym keysym;
//XLookupString( &event->xkey, buffer, 32, &keysym, NULL );
// this is for keymap support; flags are diferent from the common
// flags that existed... so this setup has to be done first for non-windows....
// and needs to be improved
SACK_Vidlib_ProcessKeyState( TRUE, event->xkey.keycode, &used );
if( !used )
used = DispatchKeyEvent( gl_camera, KEY_PRESSED|event->xkey.keycode );
}
break;
case KeyRelease:
{
int used = FALSE;
// this is for keymap support; flags are diferent from the common
// flags that existed... so this setup has to be done first for non-windows....
// and needs to be improved
SACK_Vidlib_ProcessKeyState( FALSE, event->xkey.keycode, &used );
if( !used )
used = DispatchKeyEvent( gl_camera, event->xkey.keycode );
}
break;
case ClientMessage:
{
if( event->xclient.message_type == x11_gl_window->atom_create )
{
}
char *msg = XGetAtomName( event->xany.display
, event->xclient.message_type );
if( !msg )
{
lprintf( "Received an any message with bad atom." );
break;
}
XFree( msg );
}
if (*XGetAtomName(x11_gl_window->dpy, event->xclient.message_type) ==
*"WM_PROTOCOLS")
{
BAG_Exit( 0 );
}
break;
default:
break;
}
}
int main()
{
// Create the main window
sf::Window myWindow(sf::VideoMode(800, 600, 32), "SFML/NeHe OpenGL");
initGL();
resizeGLScene(800, 600);
// Start game loop
while (myWindow.isOpen())
{
// Process events
sf::Event event;
while (myWindow.pollEvent(event))
{
// Close window : exit
switch (event.type) {
case sf::Event::Closed:
myWindow.close();
break;
// Resize event : adjust viewport
case sf::Event::Resized:
resizeGLScene(event.size.width, event.size.height);
break;
// Handle keyboard events
case sf::Event::KeyPressed:
switch (event.key.code) {
case sf::Keyboard::Escape:
myWindow.close();
break;
case sf::Keyboard::F1:
fullscreen = !fullscreen;
myWindow.create(fullscreen ? sf::VideoMode::getDesktopMode() : sf::VideoMode(800, 600, 32),
"SFML/NeHe OpenGL",
(fullscreen ? sf::Style::Fullscreen : sf::Style::Resize | sf::Style::Close));
{
sf::Vector2u size = myWindow.getSize();
resizeGLScene(size.x,size.y);
}
break;
case sf::Keyboard::F5:
vsync = !vsync;
break;
}
break;
}
}
// Turn VSYNC on so that animations run at a more reasonable speed on new CPU's/GPU's.
myWindow.setVerticalSyncEnabled(vsync);
// Set the active window before using OpenGL commands
// It's useless here because active window is always the same,
// but don't forget it if you use multiple windows or controls
myWindow.setActive();
//Draw some pretty stuff
drawGLScene();
// Finally, display rendered frame on screen
myWindow.display();
}
return EXIT_SUCCESS;
}
LRESULT CALLBACK ApplicationWindow_WGL::WndProc( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam )
{
// std::cout << "WndProc_MESSAGE" << std::endl;
if(!_inputListenersToRemove.empty())
{
// remove InputListeners before doing anything else
updateInputListeners();
}
switch (Msg)
{
case WM_ACTIVATE:
{
if (!HIWORD(wParam)) // Check Minimization State
{
_active = TRUE; // Program Is Active
}
else
{
_active = FALSE; // Program Is No Longer Active
}
break;
}
case WM_SIZE:
{
resizeGLScene(LOWORD(lParam),HIWORD(lParam)); // LoWord=Width, HiWord=Height
break;
}
case WM_CLOSE:
{
PostQuitMessage(0);
break;
}
//case WM_QUIT:
//{
// _closePending = true;
// break;
//}
case WM_LBUTTONDOWN:
{
callInputListenersMouseDown( MB_Left, Vector2(
static_cast<float>(GET_X_LPARAM(lParam)),
static_cast<float>(GET_Y_LPARAM(lParam)) ) );
break;
}
case WM_LBUTTONUP:
{
callInputListenersMouseUp( MB_Left, Vector2(
static_cast<float>(GET_X_LPARAM(lParam)),
static_cast<float>(GET_Y_LPARAM(lParam)) ) );
break;
}
case WM_MBUTTONDOWN:
{
callInputListenersMouseDown( MB_Middle, Vector2(
static_cast<float>(GET_X_LPARAM(lParam)),
static_cast<float>(GET_Y_LPARAM(lParam)) ) );
break;
}
case WM_MBUTTONUP:
{
callInputListenersMouseUp( MB_Middle, Vector2(
static_cast<float>(GET_X_LPARAM(lParam)),
static_cast<float>(GET_Y_LPARAM(lParam)) ) );
break;
}
case WM_RBUTTONDOWN:
{
callInputListenersMouseDown( MB_Right, Vector2(
static_cast<float>(GET_X_LPARAM(lParam)),
static_cast<float>(GET_Y_LPARAM(lParam)) ) );
break;
}
case WM_RBUTTONUP:
{
callInputListenersMouseUp( MB_Right, Vector2(
static_cast<float>(GET_X_LPARAM(lParam)),
static_cast<float>(GET_Y_LPARAM(lParam)) ) );
break;
}
case WM_MOUSEMOVE:
{
callInputListenersMouseMoved( Vector2(
static_cast<float>(GET_X_LPARAM(lParam)),
static_cast<float>(GET_Y_LPARAM(lParam)) ) );
break;
}
#pragma region Keyboard events
case WM_KEYDOWN:
{
switch(wParam)
{
case VK_BACK: callInputListenersKeyDown(KEY_Back); break;
case VK_TAB: callInputListenersKeyDown(KEY_Tab); break;
case VK_CLEAR: callInputListenersKeyDown(KEY_Clear); break;
case VK_RETURN: callInputListenersKeyDown(KEY_Return); break;
case VK_SHIFT: callInputListenersKeyDown(KEY_Shift); break;
case VK_CONTROL: callInputListenersKeyDown(KEY_Control); break;
case VK_MENU: callInputListenersKeyDown(KEY_Menu); break;
case VK_PAUSE: callInputListenersKeyDown(KEY_Pause); break;
case VK_CAPITAL: callInputListenersKeyDown(KEY_Capital); break;
case VK_KANA: callInputListenersKeyDown(KEY_Kana); break;
case VK_JUNJA: callInputListenersKeyDown(KEY_Junja); break;
case VK_FINAL: callInputListenersKeyDown(KEY_Final); break;
case VK_HANJA: callInputListenersKeyDown(KEY_Hanja); break;
case VK_ESCAPE: callInputListenersKeyDown(KEY_Escape); break;
case VK_CONVERT: callInputListenersKeyDown(KEY_Convert); break;
case VK_NONCONVERT: callInputListenersKeyDown(KEY_Nonconvert); break;
case VK_ACCEPT: callInputListenersKeyDown(KEY_Accept); break;
case VK_MODECHANGE: callInputListenersKeyDown(KEY_Modechange); break;
case VK_SPACE: callInputListenersKeyDown(KEY_Space); break;
case VK_PRIOR: callInputListenersKeyDown(KEY_Prior); break;
case VK_NEXT: callInputListenersKeyDown(KEY_Next); break;
case VK_END: callInputListenersKeyDown(KEY_End); break;
case VK_HOME: callInputListenersKeyDown(KEY_Home); break;
case VK_LEFT: callInputListenersKeyDown(KEY_Left); break;
case VK_UP: callInputListenersKeyDown(KEY_Up); break;
case VK_RIGHT: callInputListenersKeyDown(KEY_Right); break;
case VK_DOWN: callInputListenersKeyDown(KEY_Down); break;
case VK_SELECT: callInputListenersKeyDown(KEY_Select); break;
case VK_PRINT: callInputListenersKeyDown(KEY_Print); break;
case VK_EXECUTE: callInputListenersKeyDown(KEY_Execute); break;
case VK_SNAPSHOT: callInputListenersKeyDown(KEY_Snapshot); break;
case VK_INSERT: callInputListenersKeyDown(KEY_Insert); break;
case VK_DELETE: callInputListenersKeyDown(KEY_Delete); break;
case VK_HELP: callInputListenersKeyDown(KEY_Help); break;
case VK_LWIN: callInputListenersKeyDown(KEY_Lwin); break;
case VK_RWIN: callInputListenersKeyDown(KEY_Rwin); break;
case VK_APPS: callInputListenersKeyDown(KEY_Apps); break;
case VK_SLEEP: callInputListenersKeyDown(KEY_Sleep); break;
case VK_NUMPAD0: callInputListenersKeyDown(KEY_Numpad0); break;
case VK_NUMPAD1: callInputListenersKeyDown(KEY_Numpad1); break;
case VK_NUMPAD2: callInputListenersKeyDown(KEY_Numpad2); break;
case VK_NUMPAD3: callInputListenersKeyDown(KEY_Numpad3); break;
case VK_NUMPAD4: callInputListenersKeyDown(KEY_Numpad4); break;
case VK_NUMPAD5: callInputListenersKeyDown(KEY_Numpad5); break;
case VK_NUMPAD6: callInputListenersKeyDown(KEY_Numpad6); break;
case VK_NUMPAD7: callInputListenersKeyDown(KEY_Numpad7); break;
case VK_NUMPAD8: callInputListenersKeyDown(KEY_Numpad8); break;
case VK_NUMPAD9: callInputListenersKeyDown(KEY_Numpad9); break;
case VK_MULTIPLY: callInputListenersKeyDown(KEY_Multiply); break;
case VK_ADD: callInputListenersKeyDown(KEY_Add); break;
case VK_SEPARATOR: callInputListenersKeyDown(KEY_Separator); break;
case VK_SUBTRACT: callInputListenersKeyDown(KEY_Subtract); break;
case VK_DECIMAL: callInputListenersKeyDown(KEY_Decimal); break;
case VK_DIVIDE: callInputListenersKeyDown(KEY_Divide); break;
case VK_F1: callInputListenersKeyDown(KEY_F1); break;
case VK_F2: callInputListenersKeyDown(KEY_F2); break;
case VK_F3: callInputListenersKeyDown(KEY_F3); break;
case VK_F4: callInputListenersKeyDown(KEY_F4); break;
case VK_F5: callInputListenersKeyDown(KEY_F5); break;
case VK_F6: callInputListenersKeyDown(KEY_F6); break;
case VK_F7: callInputListenersKeyDown(KEY_F7); break;
case VK_F8: callInputListenersKeyDown(KEY_F8); break;
case VK_F9: callInputListenersKeyDown(KEY_F9); break;
case VK_F10: callInputListenersKeyDown(KEY_F10); break;
case VK_F11: callInputListenersKeyDown(KEY_F11); break;
case VK_F12: callInputListenersKeyDown(KEY_F12); break;
case VK_F13: callInputListenersKeyDown(KEY_F13); break;
case VK_F14: callInputListenersKeyDown(KEY_F14); break;
case VK_F15: callInputListenersKeyDown(KEY_F15); break;
case VK_F16: callInputListenersKeyDown(KEY_F16); break;
case VK_F17: callInputListenersKeyDown(KEY_F17); break;
case VK_F18: callInputListenersKeyDown(KEY_F18); break;
case VK_F19: callInputListenersKeyDown(KEY_F19); break;
case VK_F20: callInputListenersKeyDown(KEY_F20); break;
case VK_F21: callInputListenersKeyDown(KEY_F21); break;
case VK_F22: callInputListenersKeyDown(KEY_F22); break;
case VK_F23: callInputListenersKeyDown(KEY_F23); break;
case VK_F24: callInputListenersKeyDown(KEY_F24); break;
case VK_NUMLOCK: callInputListenersKeyDown(KEY_Numlock); break;
case VK_SCROLL: callInputListenersKeyDown(KEY_Scrolllock); break;
case VK_OEM_PLUS: callInputListenersKeyDown(KEY_OEM_Plus); break;
case VK_OEM_COMMA: callInputListenersKeyDown(KEY_OEM_Comma); break;
case VK_OEM_MINUS: callInputListenersKeyDown(KEY_OEM_Minus); break;
case VK_OEM_PERIOD: callInputListenersKeyDown(KEY_OEM_Period); break;
case 'Q': callInputListenersKeyDown(KEY_Q); break;
case 'W': callInputListenersKeyDown(KEY_W); break;
case 'E': callInputListenersKeyDown(KEY_E); break;
case 'R': callInputListenersKeyDown(KEY_R); break;
case 'T': callInputListenersKeyDown(KEY_T); break;
case 'Y': callInputListenersKeyDown(KEY_Y); break;
case 'U': callInputListenersKeyDown(KEY_U); break;
case 'I': callInputListenersKeyDown(KEY_I); break;
case 'O': callInputListenersKeyDown(KEY_O); break;
case 'P': callInputListenersKeyDown(KEY_P); break;
case 'A': callInputListenersKeyDown(KEY_A); break;
case 'S': callInputListenersKeyDown(KEY_S); break;
case 'D': callInputListenersKeyDown(KEY_D); break;
case 'F': callInputListenersKeyDown(KEY_F); break;
case 'G': callInputListenersKeyDown(KEY_G); break;
case 'H': callInputListenersKeyDown(KEY_H); break;
case 'J': callInputListenersKeyDown(KEY_J); break;
case 'K': callInputListenersKeyDown(KEY_K); break;
case 'L': callInputListenersKeyDown(KEY_L); break;
case 'Z': callInputListenersKeyDown(KEY_Z); break;
case 'X': callInputListenersKeyDown(KEY_X); break;
case 'C': callInputListenersKeyDown(KEY_C); break;
case 'V': callInputListenersKeyDown(KEY_V); break;
case 'B': callInputListenersKeyDown(KEY_B); break;
case 'N': callInputListenersKeyDown(KEY_N); break;
case 'M': callInputListenersKeyDown(KEY_M); break;
default:
break;
}
break;
}
case WM_KEYUP:
{
switch(wParam)
{
case VK_BACK: callInputListenersKeyUp(KEY_Back); break;
case VK_TAB: callInputListenersKeyUp(KEY_Tab); break;
case VK_CLEAR: callInputListenersKeyUp(KEY_Clear); break;
case VK_RETURN: callInputListenersKeyUp(KEY_Return); break;
case VK_SHIFT: callInputListenersKeyUp(KEY_Shift); break;
case VK_CONTROL: callInputListenersKeyUp(KEY_Control); break;
case VK_MENU: callInputListenersKeyUp(KEY_Menu); break;
case VK_PAUSE: callInputListenersKeyUp(KEY_Pause); break;
case VK_CAPITAL: callInputListenersKeyUp(KEY_Capital); break;
case VK_KANA: callInputListenersKeyUp(KEY_Kana); break;
case VK_JUNJA: callInputListenersKeyUp(KEY_Junja); break;
case VK_FINAL: callInputListenersKeyUp(KEY_Final); break;
case VK_HANJA: callInputListenersKeyUp(KEY_Hanja); break;
case VK_ESCAPE: callInputListenersKeyUp(KEY_Escape); break;
case VK_CONVERT: callInputListenersKeyUp(KEY_Convert); break;
case VK_NONCONVERT: callInputListenersKeyUp(KEY_Nonconvert); break;
case VK_ACCEPT: callInputListenersKeyUp(KEY_Accept); break;
case VK_MODECHANGE: callInputListenersKeyUp(KEY_Modechange); break;
case VK_SPACE: callInputListenersKeyUp(KEY_Space); break;
case VK_PRIOR: callInputListenersKeyUp(KEY_Prior); break;
case VK_NEXT: callInputListenersKeyUp(KEY_Next); break;
case VK_END: callInputListenersKeyUp(KEY_End); break;
case VK_HOME: callInputListenersKeyUp(KEY_Home); break;
case VK_LEFT: callInputListenersKeyUp(KEY_Left); break;
case VK_UP: callInputListenersKeyUp(KEY_Up); break;
case VK_RIGHT: callInputListenersKeyUp(KEY_Right); break;
case VK_DOWN: callInputListenersKeyUp(KEY_Down); break;
case VK_SELECT: callInputListenersKeyUp(KEY_Select); break;
case VK_PRINT: callInputListenersKeyUp(KEY_Print); break;
case VK_EXECUTE: callInputListenersKeyUp(KEY_Execute); break;
case VK_SNAPSHOT: callInputListenersKeyUp(KEY_Snapshot); break;
case VK_INSERT: callInputListenersKeyUp(KEY_Insert); break;
case VK_DELETE: callInputListenersKeyUp(KEY_Delete); break;
case VK_HELP: callInputListenersKeyUp(KEY_Help); break;
case VK_LWIN: callInputListenersKeyUp(KEY_Lwin); break;
case VK_RWIN: callInputListenersKeyUp(KEY_Rwin); break;
case VK_APPS: callInputListenersKeyUp(KEY_Apps); break;
case VK_SLEEP: callInputListenersKeyUp(KEY_Sleep); break;
case VK_NUMPAD0: callInputListenersKeyUp(KEY_Numpad0); break;
case VK_NUMPAD1: callInputListenersKeyUp(KEY_Numpad1); break;
case VK_NUMPAD2: callInputListenersKeyUp(KEY_Numpad2); break;
case VK_NUMPAD3: callInputListenersKeyUp(KEY_Numpad3); break;
case VK_NUMPAD4: callInputListenersKeyUp(KEY_Numpad4); break;
case VK_NUMPAD5: callInputListenersKeyUp(KEY_Numpad5); break;
case VK_NUMPAD6: callInputListenersKeyUp(KEY_Numpad6); break;
case VK_NUMPAD7: callInputListenersKeyUp(KEY_Numpad7); break;
case VK_NUMPAD8: callInputListenersKeyUp(KEY_Numpad8); break;
case VK_NUMPAD9: callInputListenersKeyUp(KEY_Numpad9); break;
case VK_MULTIPLY: callInputListenersKeyUp(KEY_Multiply); break;
case VK_ADD: callInputListenersKeyUp(KEY_Add); break;
case VK_SEPARATOR: callInputListenersKeyUp(KEY_Separator); break;
case VK_SUBTRACT: callInputListenersKeyUp(KEY_Subtract); break;
case VK_DECIMAL: callInputListenersKeyUp(KEY_Decimal); break;
case VK_DIVIDE: callInputListenersKeyUp(KEY_Divide); break;
case VK_F1: callInputListenersKeyUp(KEY_F1); break;
case VK_F2: callInputListenersKeyUp(KEY_F2); break;
case VK_F3: callInputListenersKeyUp(KEY_F3); break;
case VK_F4: callInputListenersKeyUp(KEY_F4); break;
case VK_F5: callInputListenersKeyUp(KEY_F5); break;
case VK_F6: callInputListenersKeyUp(KEY_F6); break;
case VK_F7: callInputListenersKeyUp(KEY_F7); break;
case VK_F8: callInputListenersKeyUp(KEY_F8); break;
case VK_F9: callInputListenersKeyUp(KEY_F9); break;
case VK_F10: callInputListenersKeyUp(KEY_F10); break;
case VK_F11: callInputListenersKeyUp(KEY_F11); break;
case VK_F12: callInputListenersKeyUp(KEY_F12); break;
case VK_F13: callInputListenersKeyUp(KEY_F13); break;
case VK_F14: callInputListenersKeyUp(KEY_F14); break;
case VK_F15: callInputListenersKeyUp(KEY_F15); break;
case VK_F16: callInputListenersKeyUp(KEY_F16); break;
case VK_F17: callInputListenersKeyUp(KEY_F17); break;
case VK_F18: callInputListenersKeyUp(KEY_F18); break;
case VK_F19: callInputListenersKeyUp(KEY_F19); break;
case VK_F20: callInputListenersKeyUp(KEY_F20); break;
case VK_F21: callInputListenersKeyUp(KEY_F21); break;
case VK_F22: callInputListenersKeyUp(KEY_F22); break;
case VK_F23: callInputListenersKeyUp(KEY_F23); break;
case VK_F24: callInputListenersKeyUp(KEY_F24); break;
case VK_NUMLOCK: callInputListenersKeyUp(KEY_Numlock); break;
case VK_SCROLL: callInputListenersKeyUp(KEY_Scrolllock); break;
case VK_OEM_PLUS: callInputListenersKeyUp(KEY_OEM_Plus); break;
case VK_OEM_COMMA: callInputListenersKeyUp(KEY_OEM_Comma); break;
case VK_OEM_MINUS: callInputListenersKeyUp(KEY_OEM_Minus); break;
case VK_OEM_PERIOD: callInputListenersKeyUp(KEY_OEM_Period); break;
case 'Q': callInputListenersKeyUp(KEY_Q); break;
case 'W': callInputListenersKeyUp(KEY_W); break;
case 'E': callInputListenersKeyUp(KEY_E); break;
case 'R': callInputListenersKeyUp(KEY_R); break;
case 'T': callInputListenersKeyUp(KEY_T); break;
case 'Y': callInputListenersKeyUp(KEY_Y); break;
case 'U': callInputListenersKeyUp(KEY_U); break;
case 'I': callInputListenersKeyUp(KEY_I); break;
case 'O': callInputListenersKeyUp(KEY_O); break;
case 'P': callInputListenersKeyUp(KEY_P); break;
case 'A': callInputListenersKeyUp(KEY_A); break;
case 'S': callInputListenersKeyUp(KEY_S); break;
case 'D': callInputListenersKeyUp(KEY_D); break;
case 'F': callInputListenersKeyUp(KEY_F); break;
case 'G': callInputListenersKeyUp(KEY_G); break;
case 'H': callInputListenersKeyUp(KEY_H); break;
case 'J': callInputListenersKeyUp(KEY_J); break;
case 'K': callInputListenersKeyUp(KEY_K); break;
case 'L': callInputListenersKeyUp(KEY_L); break;
case 'Z': callInputListenersKeyUp(KEY_Z); break;
case 'X': callInputListenersKeyUp(KEY_X); break;
case 'C': callInputListenersKeyUp(KEY_C); break;
case 'V': callInputListenersKeyUp(KEY_V); break;
case 'B': callInputListenersKeyUp(KEY_B); break;
case 'N': callInputListenersKeyUp(KEY_N); break;
case 'M': callInputListenersKeyUp(KEY_M); break;
default:
break;
}
break;
}
#pragma endregion
default:
// We do not want to handle this message so pass back to Windows
// to handle it in a default way
return DefWindowProc(hWnd, Msg, wParam, lParam);
}
return 0;
}
bool ApplicationWindow_WGL::createWindow( std::string title, Vector2 position, Vector2 size, bool fullscreen, const ParameterMap *parameters)
{
_renderer = Renderer::getSingletonPtr();
HWND parentWnd = nullptr;
int bpp = 32;
int PixelFormat; // Holds The Results After Searching For A Match
WNDCLASS wc; // Windows Class Structure
DWORD dwExStyle; // Window Extended Style
DWORD dwStyle; // Window Style
dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
dwStyle = WS_OVERLAPPEDWINDOW;
if(parameters != nullptr)
{
ParameterMap::const_iterator it;
ParameterMap::const_iterator itEnd = parameters->end();
if ( (it = parameters->find("parent_window")) != itEnd )
{
parentWnd = (HWND) atoi(it->second.c_str());
dwStyle = WS_CHILD;
}
}
Vector2 sceneSize = _renderer->_sceneViewMax - _renderer->_sceneViewMin;
_aspectRatio = sceneSize.x / sceneSize.y;
_fullscreen = fullscreen;
_hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
wc.lpfnWndProc = &ApplicationWindow_WGL::initialWndProc;// WndProc Handles Messages
wc.cbClsExtra = 0; // No Extra Window Data
wc.cbWndExtra = 0; // No Extra Window Data
wc.hInstance = _hInstance; // Set The Instance
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
wc.hbrBackground = NULL; // No Background Required For GL
wc.lpszMenuName = NULL; // We Don't Want A Menu
wc.lpszClassName = SKETCHYDYNAMICS_WINDOW_CLASS_NAME; // Set The Class Name
if (!RegisterClass(&wc)) // Attempt To Register The Window Class
{
Logger::getSingletonPtr()->writeError("{ApplicationWindow_WGL}Failed To Register The Window Class");
return FALSE; // Return FALSE
}
if (fullscreen) // Attempt Fullscreen Mode?
{
DEVMODE dmScreenSettings; // Device Mode
memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Makes Sure Memory's Cleared
dmScreenSettings.dmSize=sizeof(dmScreenSettings); // Size Of The Devmode Structure
dmScreenSettings.dmPelsWidth = (long)size.x; // Selected Screen Width
dmScreenSettings.dmPelsHeight = (long)size.y; // Selected Screen Height
dmScreenSettings.dmBitsPerPel = bpp; // Selected Bits Per Pixel
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
// Try To Set Selected Mode And Get Results. NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
{
// If The Mode Fails, Use Windowed Mode.
fullscreen=FALSE;
Logger::getSingletonPtr()->writeWarning("Fullscreen mode not supported");
}
}
if (fullscreen) // Are We Still In Fullscreen Mode?
{
dwExStyle=WS_EX_APPWINDOW; // Window Extended Style
dwStyle=WS_POPUP; // Windows Style
//ShowCursor(FALSE); // Hide Mouse Pointer
}
RECT WindowRect;
WindowRect.left = (long)position.x;
WindowRect.right = (long)(position.x + size.x);
WindowRect.top = (long)position.y;
WindowRect.bottom = (long)(position.y + size.y);
AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requested Size
// Create The Window
if (!(_hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window
SKETCHYDYNAMICS_WINDOW_CLASS_NAME, // Class Name
title.c_str(), // Window Title
dwStyle | // Defined Window Style
WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN, // Required Window Style
(int)position.x, (int)position.y, // Window Position
WindowRect.right-WindowRect.left, // Calculate Window Width
WindowRect.bottom-WindowRect.top, // Calculate Window Height
parentWnd, // Parent Window
NULL, // No Menu
_hInstance, // Instance
this))) // Pass To WM_CREATE
{
destroyWindow(); // Reset The Display
Logger::getSingletonPtr()->writeError("{ApplicationWindow_WGL}Window Creation Error");
return FALSE; // Return FALSE
}
static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be
{
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
bpp, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};
if (!(_hDC=GetDC(_hWnd))) // Did We Get A Device Context?
{
destroyWindow(); // Reset The Display
Logger::getSingletonPtr()->writeError("{ApplicationWindow_WGL}Can't Create A GL Device Context");
return FALSE; // Return FALSE
}
if (!(PixelFormat=ChoosePixelFormat(_hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
{
destroyWindow(); // Reset The Display
Logger::getSingletonPtr()->writeError("{ApplicationWindow_WGL}Can't Find A Suitable PixelFormat");
return FALSE; // Return FALSE
}
if(!SetPixelFormat(_hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
{
destroyWindow(); // Reset The Display
Logger::getSingletonPtr()->writeError("{ApplicationWindow_WGL}Can't Set The PixelFormat");
return FALSE; // Return FALSE
}
if (!(_hRC=wglCreateContext(_hDC))) // Are We Able To Get A Rendering Context?
{
destroyWindow(); // Reset The Display
Logger::getSingletonPtr()->writeError("{ApplicationWindow_WGL}Can't Create A GL Rendering Context");
return FALSE; // Return FALSE
}
if(!wglMakeCurrent(_hDC,_hRC)) // Try To Activate The Rendering Context
{
destroyWindow(); // Reset The Display
Logger::getSingletonPtr()->writeError("{ApplicationWindow_WGL}Can't Activate The GL Rendering Context");
return FALSE; // Return FALSE
}
ShowWindow(_hWnd, SW_SHOW); // Show The Window
SetForegroundWindow(_hWnd); // Slightly Higher Priority
SetFocus(_hWnd); // Sets Keyboard Focus To The Window
resizeGLScene((int)size.x, (int)size.y); // Set Up Our Perspective GL Screen
if(!_renderer->initGL())
{
SKETCHYDYNAMICS_LOG_ERROR("OpenGL init failed");
destroyWindow();
return FALSE;
}
setVSync(false);
return TRUE; // Success
}
