int main(){
window.create(sf::VideoMode((unsigned int)windowWidth,(unsigned int)windowHeight),"MyWindow");
window.setFramerateLimit(60);
Setup();
running=true;
while(running){
while(window.pollEvent(event)){
if(event.type==sf::Event::Closed)
running=false;
else if(event.type==sf::Event::Resized)
ReshapeWindow((float)event.size.width,(float)event.size.height);
}
if (currentState == MAIN)
{
cmain.HandleKeyboard();
cmain.mouseControl();
}
else if (currentState == GAME)
{
cgame.HandleKeyboard();
handleKeyboard();
}
Display();
window.display();
}
return 0;
}
void SetupGL(){
ReshapeWindow(windowWidth,windowHeight);
glEnable(GL_DEPTH_TEST);
glClearColor(0.0f,0.0f,0.0f,1);
initShapes();
//cat.loadFromFile("grumpy.png");
}
/*standard OpenGL initialization*/
static bool initialize(const char *filename) {
if (!g_input.LoadImageFromFile(filename, false )) return false;
sProgram = new ProgramGLSL("SelectChannel.glsl");
sProgram->AttachShaderObject(
ShaderObject( GL_FRAGMENT_SHADER, "SelectChannel.glsl", true ) );
if (!sProgram->LinkProgram()) return false;
g_img_width = g_input.GetImageWidth();
g_img_height = g_input.GetDrawHeight();
ReshapeWindow( g_img_width, g_img_height );
g_pyramid = new PyramidGLSL( &g_input, g_sp.GetSigmas(), g_sp.GetLevels() );
return true;
}
bool Application::InitOpenGL()
{
#ifdef WIN32
wglSwapIntervalEXT_Func wglSwapIntervalEXT = (wglSwapIntervalEXT_Func)wglGetProcAddress("wglSwapIntervalEXT");
if(wglSwapIntervalEXT) wglSwapIntervalEXT(Globals.VP.Vsync);//1 - чтобы включить
else FASSERT (wglSwapIntervalEXT);
#else
#error Linux is not supported yet
#endif
LF.Logf("InitOpenGL","Vsync status : %d",Globals.VP.Vsync);
//===[ Инициализация всякой фигни ]===================================================||
Cam.Init();
//===[ Наинициализировались ]=========================================================||
glClearColor(0.0f, 0.0f, 0.25f, 0.0f);
// Очистка экрана в черный цвет
glClearDepth(1.0); // Разрешить очистку буфера глубины
glDepthFunc(GL_LESS); // Тип теста глубины (рисуется всё что ближе)
glEnable(GL_DEPTH_TEST);// разрешить тест глубины
glShadeModel(GL_SMOOTH);// разрешить плавное цветовое сглаживание
ReshapeWindow(Globals.VP.Width,Globals.VP.Height);
glEnable(GL_TEXTURE_2D); // Разрешение наложения текстур
glClearDepth(1.0f); // Установка буфера глубины
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Улучшенные вычисления перспективы
glDisable(GL_POLYGON_SMOOTH);
glHint(GL_POLYGON_SMOOTH_HINT,GL_NICEST);
glHint(GL_POINT_SMOOTH_HINT,GL_NICEST);
glEnable(GL_DITHER);
//glEnable(GL_CULL_FACE);
//==== Свет ==========================================================================//
glEnable(GL_LIGHT1); // Разрешение источника света номер один
glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); // Установка Фонового Света
glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); // Установка Диффузного Света
glLightfv(GL_LIGHT1, GL_POSITION, LightPosition); // Позиция света
glEnable(GL_LIGHTING);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE,0.0);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_TRUE);
//=== /Свет ==========================================================================//
return NO_ERROR;
}
/** Toggle native window between fullscreen and normal mode */
void FWindowsWindow::SetWindowMode( EWindowMode::Type NewWindowMode )
{
EWindowMode::Type InNewWindowMode = NewWindowMode;
if (InNewWindowMode == EWindowMode::WindowedMirror)
{
// treat WindowedMirror as a regular Windowed mode here
InNewWindowMode = EWindowMode::Windowed;
}
if( InNewWindowMode != WindowMode )
{
bool bTrueFullscreen = NewWindowMode == EWindowMode::Fullscreen;
// Setup Win32 Flags to be used for Fullscreen mode
LONG WindowStyle = GetWindowLong(HWnd, GWL_STYLE);
const LONG FullscreenModeStyle = WS_POPUP;
LONG WindowedModeStyle = WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION;
if (IsRegularWindow())
{
if (Definition->SupportsMaximize)
{
WindowedModeStyle |= WS_MAXIMIZEBOX;
}
if (Definition->SupportsMinimize)
{
WindowedModeStyle |= WS_MINIMIZEBOX;
}
if (Definition->HasSizingFrame)
{
WindowedModeStyle |= WS_THICKFRAME;
}
else
{
WindowedModeStyle |= WS_BORDER;
}
}
else
{
WindowedModeStyle |= WS_POPUP | WS_BORDER;
}
// If we're not in fullscreen, make it so
if( NewWindowMode == EWindowMode::WindowedFullscreen || NewWindowMode == EWindowMode::Fullscreen)
{
::GetWindowPlacement(HWnd, &PreFullscreenWindowPlacement);
// Setup Win32 flags for fullscreen window
WindowStyle &= ~WindowedModeStyle;
WindowStyle |= FullscreenModeStyle;
SetWindowLong(HWnd, GWL_STYLE, WindowStyle);
::SetWindowPos(HWnd, nullptr, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
if (!bTrueFullscreen)
{
// Ensure the window is restored if we are going for WindowedFullscreen
ShowWindow(HWnd, SW_RESTORE);
}
// Get the current window position.
RECT ClientRect;
GetClientRect(HWnd, &ClientRect);
// Grab current monitor data for sizing
HMONITOR Monitor = MonitorFromWindow( HWnd, bTrueFullscreen ? MONITOR_DEFAULTTOPRIMARY : MONITOR_DEFAULTTONEAREST );
MONITORINFO MonitorInfo;
MonitorInfo.cbSize = sizeof(MONITORINFO);
GetMonitorInfo( Monitor, &MonitorInfo );
// Get the target client width to send to ReshapeWindow.
// Preserve the current res if going to true fullscreen and the monitor supports it and allow the calling code
// to resize if required.
// Else, use the monitor's res for windowed fullscreen.
LONG MonitorWidth = MonitorInfo.rcMonitor.right - MonitorInfo.rcMonitor.left;
LONG TargetClientWidth = bTrueFullscreen ?
FMath::Min(MonitorWidth, ClientRect.right - ClientRect.left) :
MonitorWidth;
LONG MonitorHeight = MonitorInfo.rcMonitor.bottom - MonitorInfo.rcMonitor.top;
LONG TargetClientHeight = bTrueFullscreen ?
FMath::Min(MonitorHeight, ClientRect.bottom - ClientRect.top) :
MonitorHeight;
// Resize and position fullscreen window
ReshapeWindow(
MonitorInfo.rcMonitor.left,
MonitorInfo.rcMonitor.top,
TargetClientWidth,
TargetClientHeight);
}
else
{
// Windowed:
// Setup Win32 flags for restored window
WindowStyle &= ~FullscreenModeStyle;
WindowStyle |= WindowedModeStyle;
SetWindowLong(HWnd, GWL_STYLE, WindowStyle);
::SetWindowPos(HWnd, nullptr, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
::SetWindowPlacement(HWnd, &PreFullscreenWindowPlacement);
}
WindowMode = NewWindowMode;
}
}
void FWindowsWindow::Initialize( FWindowsApplication* const Application, const TSharedRef< FGenericWindowDefinition >& InDefinition, HINSTANCE InHInstance, const TSharedPtr< FWindowsWindow >& InParent, const bool bShowImmediately )
{
Definition = InDefinition;
OwningApplication = Application;
// Finally, let's initialize the new native window object. Calling this function will often cause OS
// window messages to be sent! (such as activation messages)
uint32 WindowExStyle = 0;
uint32 WindowStyle = 0;
RegionWidth = RegionHeight = INDEX_NONE;
const float XInitialRect = Definition->XDesiredPositionOnScreen;
const float YInitialRect = Definition->YDesiredPositionOnScreen;
const float WidthInitial = Definition->WidthDesiredOnScreen;
const float HeightInitial = Definition->HeightDesiredOnScreen;
int32 X = FMath::TruncToInt( XInitialRect );
int32 Y = FMath::TruncToInt( YInitialRect );
int32 ClientWidth = FMath::TruncToInt( WidthInitial );
int32 ClientHeight = FMath::TruncToInt( HeightInitial );
int32 WindowWidth = ClientWidth;
int32 WindowHeight = ClientHeight;
const bool bApplicationSupportsPerPixelBlending =
#if ALPHA_BLENDED_WINDOWS
Application->GetWindowTransparencySupport() == EWindowTransparency::PerPixel;
#else
false;
#endif
if( !Definition->HasOSWindowBorder )
{
WindowExStyle = WS_EX_WINDOWEDGE;
if( Definition->TransparencySupport == EWindowTransparency::PerWindow )
{
WindowExStyle |= WS_EX_LAYERED;
}
#if ALPHA_BLENDED_WINDOWS
else if( Definition->TransparencySupport == EWindowTransparency::PerPixel )
{
if( bApplicationSupportsPerPixelBlending )
{
WindowExStyle |= WS_EX_COMPOSITED;
}
}
#endif
WindowStyle = WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
if ( Definition->AppearsInTaskbar )
{
WindowExStyle |= WS_EX_APPWINDOW;
}
else
{
WindowExStyle |= WS_EX_TOOLWINDOW;
}
if( Definition->IsTopmostWindow )
{
// Tool tips are always top most windows
WindowExStyle |= WS_EX_TOPMOST;
}
if ( !Definition->AcceptsInput )
{
// Window should never get input
WindowExStyle |= WS_EX_TRANSPARENT;
}
}
else
{
// OS Window border setup
WindowExStyle = WS_EX_APPWINDOW;
WindowStyle = WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION;
if (IsRegularWindow())
{
if (Definition->SupportsMaximize)
{
WindowStyle |= WS_MAXIMIZEBOX;
}
if (Definition->SupportsMinimize)
{
WindowStyle |= WS_MINIMIZEBOX;
}
if (Definition->HasSizingFrame)
{
WindowStyle |= WS_THICKFRAME;
}
else
{
WindowStyle |= WS_BORDER;
}
}
else
{
WindowStyle |= WS_POPUP | WS_BORDER;
}
// Note SizeX and SizeY should be the size of the client area. We need to get the actual window size by adjusting the client size to account for standard windows border around the window
RECT WindowRect = { 0, 0, ClientWidth, ClientWidth };
::AdjustWindowRectEx(&WindowRect,WindowStyle,0,WindowExStyle);
X += WindowRect.left;
Y += WindowRect.top;
WindowWidth = WindowRect.right - WindowRect.left;
WindowHeight = WindowRect.bottom - WindowRect.top;
}
// Creating the Window
HWnd = CreateWindowEx(
WindowExStyle,
AppWindowClass,
*Definition->Title,
WindowStyle,
X, Y, WindowWidth, WindowHeight,
( InParent.IsValid() ) ? static_cast<HWND>( InParent->HWnd ) : NULL,
NULL, InHInstance, NULL);
VirtualWidth = ClientWidth;
VirtualHeight = ClientHeight;
// We call reshape window here because we didn't take into account the non-client area
// in the initial creation of the window. Slate should only pass client area dimensions.
// Reshape window may resize the window if the non-client area is encroaching on our
// desired client area space.
ReshapeWindow( X, Y, ClientWidth, ClientHeight );
if( HWnd == NULL )
{
// @todo Error message should be localized!
MessageBox(NULL, TEXT("Window Creation Failed!"), TEXT("Error!"), MB_ICONEXCLAMATION | MB_OK);
checkf(0, TEXT("Window Creation Failed (%d)"), ::GetLastError() );
return;
}
if ( Definition->TransparencySupport == EWindowTransparency::PerWindow )
{
SetOpacity( Definition->Opacity );
}
#if WINVER > 0x502 // Windows Vista or better required for DWM
// Disable DWM Rendering and Nonclient Area painting if not showing the os window border
// This prevents the standard windows frame from ever being drawn
if( !Definition->HasOSWindowBorder )
{
const DWMNCRENDERINGPOLICY RenderingPolicy = DWMNCRP_DISABLED;
verify(SUCCEEDED(DwmSetWindowAttribute(HWnd, DWMWA_NCRENDERING_POLICY, &RenderingPolicy, sizeof(RenderingPolicy))));
const BOOL bEnableNCPaint = false;
verify(SUCCEEDED(DwmSetWindowAttribute(HWnd, DWMWA_ALLOW_NCPAINT, &bEnableNCPaint, sizeof(bEnableNCPaint))));
#if ALPHA_BLENDED_WINDOWS
if ( bApplicationSupportsPerPixelBlending && Definition->TransparencySupport == EWindowTransparency::PerPixel )
{
MARGINS Margins = {-1};
verify(SUCCEEDED(::DwmExtendFrameIntoClientArea(HWnd, &Margins)));
}
#endif
}
#endif // WINVER
// No region for non regular windows or windows displaying the os window border
if ( IsRegularWindow() && !Definition->HasOSWindowBorder )
{
WindowStyle |= WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU;
if ( Definition->SupportsMaximize )
{
WindowStyle |= WS_MAXIMIZEBOX;
}
if ( Definition->SupportsMinimize )
{
WindowStyle |= WS_MINIMIZEBOX;
}
if ( Definition->HasSizingFrame )
{
WindowStyle |= WS_THICKFRAME;
}
verify(SetWindowLong(HWnd, GWL_STYLE, WindowStyle));
::SetWindowPos(HWnd, nullptr, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
AdjustWindowRegion( ClientWidth, ClientHeight );
}
if ( IsRegularWindow() )
{
// Tell OLE that we are opting into drag and drop.
// Only makes sense for regular windows (windows that last a while.)
RegisterDragDrop( HWnd, this );
}
}
// HINSTANCE InHInstance,
void FLinuxWindow::Initialize( FLinuxApplication* const Application, const TSharedRef< FGenericWindowDefinition >& InDefinition, const TSharedPtr< FLinuxWindow >& InParent, const bool bShowImmediately )
{
Definition = InDefinition;
OwningApplication = Application;
ParentWindow = InParent;
if (!FPlatformMisc::PlatformInitMultimedia()) // will not initialize more than once
{
UE_LOG(LogInit, Fatal, TEXT("FLinuxWindow::Initialize() : PlatformInitMultimedia() failed, cannot initialize window."));
// unreachable
return;
}
#if DO_CHECK
uint32 InitializedSubsystems = SDL_WasInit(SDL_INIT_EVERYTHING);
check(InitializedSubsystems & SDL_INIT_VIDEO);
#endif // DO_CHECK
// Finally, let's initialize the new native window object. Calling this function will often cause OS
// window messages to be sent! (such as activation messages)
uint32 WindowExStyle = 0;
uint32 WindowStyle = 0;
RegionWidth = RegionHeight = INDEX_NONE;
const float XInitialRect = Definition->XDesiredPositionOnScreen;
const float YInitialRect = Definition->YDesiredPositionOnScreen;
const float WidthInitial = Definition->WidthDesiredOnScreen;
const float HeightInitial = Definition->HeightDesiredOnScreen;
int32 X = FMath::TruncToInt( XInitialRect + 0.5f );
int32 Y = FMath::TruncToInt( YInitialRect + 0.5f );
int32 ClientWidth = FMath::TruncToInt( WidthInitial + 0.5f );
int32 ClientHeight = FMath::TruncToInt( HeightInitial + 0.5f );
int32 WindowWidth = ClientWidth;
int32 WindowHeight = ClientHeight;
WindowStyle |= SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
if ( !Definition->HasOSWindowBorder )
{
WindowStyle |= SDL_WINDOW_BORDERLESS;
if (Definition->IsTopmostWindow)
{
WindowStyle |= SDL_WINDOW_ALWAYS_ON_TOP;
}
if (!Definition->AppearsInTaskbar)
{
WindowStyle |= SDL_WINDOW_SKIP_TASKBAR;
}
if (Definition->IsRegularWindow && Definition->HasSizingFrame)
{
WindowStyle |= SDL_WINDOW_RESIZABLE;
}
}
// This is a tool tip window.
if (!InParent.IsValid() && !Definition->HasOSWindowBorder &&
!Definition->AcceptsInput && Definition->IsTopmostWindow &&
!Definition->AppearsInTaskbar && !Definition->HasSizingFrame &&
!Definition->IsModalWindow && !Definition->IsRegularWindow &&
Definition->SizeWillChangeOften)
{
WindowStyle |= SDL_WINDOW_TOOLTIP;
bIsTooltipWindow = true;
UE_LOG(LogLinuxWindowType, Verbose, TEXT("*** New Window is a Tooltip Window ***"));
}
// This is a notification window.
else if (InParent.IsValid() && !Definition->HasOSWindowBorder &&
Definition->AcceptsInput && !Definition->IsTopmostWindow &&
!Definition->AppearsInTaskbar && !Definition->HasSizingFrame &&
!Definition->IsModalWindow && !Definition->IsRegularWindow &&
!Definition->ActivateWhenFirstShown && Definition->SizeWillChangeOften)
{
WindowStyle |= SDL_WINDOW_NOTIFICATION;
bIsNotificationWindow = true;
UE_LOG(LogLinuxWindowType, Verbose, TEXT("*** New Window is a Notification Window ***"));
}
// Is it another notification window?
else if (InParent.IsValid() && !Definition->HasOSWindowBorder &&
Definition->AcceptsInput && !Definition->IsTopmostWindow &&
!Definition->AppearsInTaskbar && !Definition->HasSizingFrame &&
Definition->IsModalWindow && !Definition->IsRegularWindow &&
Definition->ActivateWhenFirstShown && !Definition->SizeWillChangeOften)
{
WindowStyle |= SDL_WINDOW_NOTIFICATION;
bIsNotificationWindow = true;
UE_LOG(LogLinuxWindowType, Verbose, TEXT("*** New Window is another Notification Window ***"));
}
// This is a popup menu window?
else if (InParent.IsValid() && !Definition->HasOSWindowBorder &&
Definition->AcceptsInput && !Definition->IsTopmostWindow &&
!Definition->AppearsInTaskbar && !Definition->HasSizingFrame &&
!Definition->IsModalWindow && !Definition->IsRegularWindow &&
Definition->ActivateWhenFirstShown && !Definition->SizeWillChangeOften)
{
WindowStyle |= SDL_WINDOW_POPUP_MENU;
bIsPopupWindow = true;
UE_LOG(LogLinuxWindowType, Verbose, TEXT("*** New Window is a Popup Menu Window ***"));
}
// Is it a console window?
else if( InParent.IsValid() && !Definition->HasOSWindowBorder &&
Definition->AcceptsInput && !Definition->IsTopmostWindow &&
!Definition->AppearsInTaskbar && !Definition->HasSizingFrame &&
!Definition->IsModalWindow && !Definition->IsRegularWindow &&
!Definition->ActivateWhenFirstShown && !Definition->SizeWillChangeOften)
{
WindowStyle |= SDL_WINDOW_POPUP_MENU;
bIsConsoleWindow = true;
bIsPopupWindow = true;
UE_LOG(LogLinuxWindowType, Verbose, TEXT("*** New Window is a Console Window ***"));
}
// Is it a drag and drop window?
else if (!InParent.IsValid() && !Definition->HasOSWindowBorder &&
!Definition->AcceptsInput && Definition->IsTopmostWindow &&
!Definition->AppearsInTaskbar && !Definition->HasSizingFrame &&
!Definition->IsModalWindow && !Definition->IsRegularWindow &&
!Definition->ActivateWhenFirstShown && !Definition->SizeWillChangeOften)
{
// TODO Experimental (The SDL_WINDOW_DND sets focus)
WindowStyle |= SDL_WINDOW_DND;
bIsDragAndDropWindow = true;
UE_LOG(LogLinuxWindowType, Verbose, TEXT("*** New Window is a Drag and Drop Window ***"));
}
// Is modal dialog window?
else if (InParent.IsValid() && !Definition->HasOSWindowBorder &&
Definition->AcceptsInput && !Definition->IsTopmostWindow &&
Definition->AppearsInTaskbar && !Definition->HasSizingFrame &&
Definition->IsModalWindow && Definition->IsRegularWindow &&
Definition->ActivateWhenFirstShown && !Definition->SizeWillChangeOften)
{
WindowStyle |= SDL_WINDOW_DIALOG;
bIsDialogWindow = true;
UE_LOG(LogLinuxWindowType, Verbose, TEXT("*** New Window is a Modal Dialog Window ***"));
}
// Is a Blueprint, Cascade, etc. utility window.
else if (InParent.IsValid() && !Definition->HasOSWindowBorder &&
Definition->AcceptsInput && !Definition->IsTopmostWindow &&
Definition->AppearsInTaskbar && Definition->HasSizingFrame &&
!Definition->IsModalWindow && Definition->IsRegularWindow &&
Definition->ActivateWhenFirstShown && !Definition->SizeWillChangeOften)
{
WindowStyle |= SDL_WINDOW_DIALOG;
bIsUtilityWindow = true;
UE_LOG(LogLinuxWindowType, Verbose, TEXT("*** New Window is a BP, Cascade, etc. Window ***"));
}
else
{
UE_LOG(LogLinuxWindowType, Verbose, TEXT("*** New Window is TopLevel Window ***"));
bIsTopLevelWindow = true;
}
// The SDL window doesn't need to be reshaped.
// the size of the window you input is the sizeof the client.
HWnd = SDL_CreateWindow( TCHAR_TO_ANSI( *Definition->Title ), X, Y, ClientWidth, ClientHeight, WindowStyle );
SDL_SetWindowHitTest( HWnd, FLinuxWindow::HitTest, this );
/*
Do not set for Notification Windows the transient flag because the WM's usually raise the the parent window
if the Notificaton Window gets raised. That behaviour is to aggresive and disturbs users doing other things
while UE4 calculates lights and other things and pop ups notifications. Notifications will be handled so that
they are some sort of independend but will be raised if the TopLevel Window gets focused or activated.
*/
// Make the Window modal for it's parent.
if (bIsUtilityWindow || bIsDialogWindow || bIsConsoleWindow || bIsDialogWindow)
{
SDL_SetWindowModalFor(HWnd, InParent->GetHWnd());
}
VirtualWidth = ClientWidth;
VirtualHeight = ClientHeight;
// attempt to early cache native properties
CacheNativeProperties();
// We call reshape window here because we didn't take into account the non-client area
// in the initial creation of the window. Slate should only pass client area dimensions.
// Reshape window may resize the window if the non-client area is encroaching on our
// desired client area space.
ReshapeWindow( X, Y, ClientWidth, ClientHeight );
if (HWnd == nullptr)
{
// @todo Error message should be localized!
checkf(false, TEXT("Window creation failed (%s)"), UTF8_TO_TCHAR(SDL_GetError()));
return;
}
if ( Definition->TransparencySupport == EWindowTransparency::PerWindow )
{
SetOpacity( Definition->Opacity );
}
// TODO This can be removed later - for debugging purposes.
WindowSDLID = SDL_GetWindowID( HWnd );
}
