static GPU_Target* Init(GPU_Renderer* renderer, GPU_RendererID renderer_request, Uint16 w, Uint16 h, GPU_WindowFlagEnum SDL_flags)
{
SDL_Window* window;
GPU_Log(" %s (dummy)\n", __func__);
renderer->requested_id = renderer_request;
renderer->GPU_init_flags = GPU_GetPreInitFlags();
renderer->SDL_init_flags = SDL_flags;
window = NULL;
// Is there a window already set up that we are supposed to use?
if(renderer->current_context_target != NULL)
window = SDL_GetWindowFromID(renderer->current_context_target->context->windowID);
else
window = SDL_GetWindowFromID(GPU_GetInitWindow());
if(window == NULL)
{
// Set up window flags
if(!(renderer->SDL_init_flags & SDL_WINDOW_HIDDEN))
renderer->SDL_init_flags |= SDL_WINDOW_SHOWN;
window = SDL_CreateWindow("",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
w, h,
renderer->SDL_init_flags);
if(window == NULL)
{
GPU_PushErrorCode("GPU_Init", GPU_ERROR_BACKEND_ERROR, "Window creation failed.");
return NULL;
}
GPU_SetInitWindow(SDL_GetWindowID(window));
}
else
renderer->SDL_init_flags = SDL_flags;
renderer->enabled_features = 0xFFFFFFFF; // Pretend to support them all
renderer->current_context_target = renderer->impl->CreateTargetFromWindow(renderer, SDL_GetWindowID(window), renderer->current_context_target);
if(renderer->current_context_target == NULL)
return NULL;
// If the dimensions of the window don't match what we asked for, then set up a virtual resolution to pretend like they are.
if(!(renderer->GPU_init_flags & GPU_INIT_DISABLE_AUTO_VIRTUAL_RESOLUTION) && w != 0 && h != 0 && (w != renderer->current_context_target->w || h != renderer->current_context_target->h))
renderer->impl->SetVirtualResolution(renderer, renderer->current_context_target, w, h);
return renderer->current_context_target;
}
bool LWindow::init() {
//Create window
mWindow = SDL_CreateWindow( "SDL Tutorial", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE );
if( mWindow != NULL ) {
mMouseFocus = true;
mKeyboardFocus = true;
mWidth = SCREEN_WIDTH;
mHeight = SCREEN_HEIGHT;
//Create renderer for window
mRenderer = SDL_CreateRenderer( mWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC );
if( mRenderer == NULL ) {
printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
SDL_DestroyWindow( mWindow );
mWindow = NULL;
} else {
//Initialize renderer color
SDL_SetRenderDrawColor( mRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
//Grab window identifier
mWindowID = SDL_GetWindowID( mWindow );
//Flag as opened
mShown = true;
}
} else {
printf( "Window could not be created! SDL Error: %s\n", SDL_GetError() );
}
return mWindow != NULL && mRenderer != NULL;
}
bool Multitouch::wasTouchActive(Window*window, unsigned int touchID)
{
if(window == nullptr)
{
SDL_Window*sdlwin = SDL_GetMouseFocus();
if(sdlwin != nullptr)
{
window = EventManager::getWindowFromID(SDL_GetWindowID(sdlwin));
if(window == nullptr)
{
return false;
}
}
}
bool pressed = false;
Multitouch_state_mutex.lock();
unsigned int index = Multitouch_indexOfData(Multitouch_prevActiveTouches, window, touchID);
if(index != ARRAYLIST_NOTFOUND)
{
pressed = true;
}
Multitouch_state_mutex.unlock();
return pressed;
}
Vector2d Multitouch::getPreviousPosition(Window*window, unsigned int touchID)
{
if(window == nullptr)
{
SDL_Window*sdlwin = SDL_GetMouseFocus();
if(sdlwin != nullptr)
{
window = EventManager::getWindowFromID(SDL_GetWindowID(sdlwin));
if(window == nullptr)
{
return Vector2d(0,0);
}
}
}
Multitouch_state_mutex.lock();
unsigned int index = Multitouch_indexOfData(Multitouch_prevActiveTouches, window, touchID);
if(index == ARRAYLIST_NOTFOUND)
{
Multitouch_state_mutex.unlock();
return Vector2d(0,0);
}
Vector2d vect = Multitouch_prevActiveTouches.get(index).position;
Multitouch_state_mutex.unlock();
return vect;
}
WindowHandle WindowSystem::create(uint32_t width, uint32_t height)
{
WindowData data;
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE,8);
data.sdl_window = SDL_CreateWindow(
"",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
width, height,
SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL);
uint32_t id = SDL_GetWindowID((SDL_Window*)data.sdl_window);
m_data.insert(std::make_pair(id,data));
if (m_gl_context == nullptr) {
m_gl_context = SDL_GL_CreateContext( (SDL_Window*)data.sdl_window );
if( m_gl_context == nullptr )
{
printf( "OpenGL context could not be created! SDL Error: %s\n", SDL_GetError() );
return WindowHandle();
}
}
if (m_data.size() == 1) m_main_window = id;
return WindowHandle(id);
}
Vector2d Mouse::getPreviousPosition(Window*window, unsigned int mouseIndex)
{
if(window == nullptr)
{
SDL_Window*sdlwin = SDL_GetMouseFocus();
if(sdlwin != nullptr)
{
window = EventManager::getWindowFromID(SDL_GetWindowID(sdlwin));
if(window == nullptr)
{
return Vector2d(0,0);
}
}
}
Mouse_state_mutex.lock();
unsigned int index = Mouse_indexOfData(Mouse_prevStates, window, mouseIndex);
if(index == ARRAYLIST_NOTFOUND)
{
Mouse_state_mutex.unlock();
return Vector2d(0,0);
}
Vector2d vect = Mouse_prevStates.get(index).position;
Mouse_state_mutex.unlock();
return vect;
}
/// Called by view factory to create window
void PlasmacoreView::init ()
{
printf("LOG: PlasmacoreView::init()\n");
#ifdef __EMSCRIPTEN__
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
#endif
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
create_window();
if (!window) throw "Didn't create window";
gl_context = SDL_GL_CreateContext(window);
if (!gl_context) throw "Didn't create GL context";
swindowID = SDL_GetWindowID(window);
sdl_windows[swindowID] = this;
if (SDL_GL_MakeCurrent(window, gl_context))
{
fprintf( stderr, "SDL_GL_MakeCurrent() failed: %s\n", SDL_GetError() );
return;
}
glClearColor(1,1,0,1);
glClear(GL_COLOR_BUFFER_BIT);
configure(); // Is there a reason not to call this here?
}
bool Mouse::wasButtonPressed(Window*window, unsigned int mouseIndex, Mouse::Button button)
{
if(window == nullptr)
{
SDL_Window*sdlwin = SDL_GetMouseFocus();
if(sdlwin != nullptr)
{
window = EventManager::getWindowFromID(SDL_GetWindowID(sdlwin));
if(window == nullptr)
{
return false;
}
}
}
bool pressed = false;
Mouse_state_mutex.lock();
unsigned int index = Mouse_indexOfData(Mouse_prevStates, window, mouseIndex);
if(index != ARRAYLIST_NOTFOUND)
{
if(Mouse_prevStates[index].state[button])
{
pressed = true;
}
}
Mouse_state_mutex.unlock();
return pressed;
}
ross_internal void
manage_events(Input input, SDL_Window *window)
{
if(input.keyboard.alt && input.keyboard.f4)
{
global_running = 0;
}
SDL_Event event;
while(SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_WINDOWEVENT:
{
u32 window_id = SDL_GetWindowID(window);
if(event.window.windowID == window_id)
{
switch(event.window.event)
{
case SDL_WINDOWEVENT_CLOSE:
{
global_running = 0;
} break;
}
}
} break;
case SDL_QUIT:
{
global_running = 0;
} break;
}
}
}
bool isWindowEvent(const SDL_Event& e, SDL_Window* window)
{
auto mainId = SDL_GetWindowID(window);
switch(e.type)
{
case SDL_WINDOWEVENT:
return mainId == e.window.windowID;
case SDL_KEYDOWN:
case SDL_KEYUP:
return mainId == e.key.windowID;
case SDL_TEXTEDITING:
return mainId == e.edit.windowID;
case SDL_TEXTINPUT:
return mainId == e.text.windowID;
case SDL_MOUSEMOTION:
return mainId == e.motion.windowID;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
return mainId == e.button.windowID;
case SDL_MOUSEWHEEL:
return mainId == e.wheel.windowID;
default:
// Event doesn't have a window ID
return true;
}
}
void SDLEventHandler::onWindowEvent(const SDL_WindowEvent& e)
{
/*
*SDL provides two "resize" events.
* Warp Drive only provides treatment for the "resize request"
* type, for the moment. Should it prove useful, this will be ammended
*/
if (e.windowID != SDL_GetWindowID(DisplayManager::instance()->getScreen()))
{
return;
}
switch (e.event)
{
case SDL_WINDOWEVENT_SHOWN:
onWindowShown(e);
break;
case SDL_WINDOWEVENT_HIDDEN:
onWindowHidden(e);
break;
case SDL_WINDOWEVENT_EXPOSED:
onWindowExposed(e);
break;
case SDL_WINDOWEVENT_MOVED:
onWindowMoved(e);
break;
case SDL_WINDOWEVENT_SIZE_CHANGED:
onWindowResized(e);
break;
case SDL_WINDOWEVENT_MINIMIZED:
onWindowMinimized(e);
break;
case SDL_WINDOWEVENT_MAXIMIZED:
onWindowMaximized(e);
break;
case SDL_WINDOWEVENT_RESTORED:
onWindowRestored(e);
break;
case SDL_WINDOWEVENT_ENTER:
onMouseEntered(e);
break;
case SDL_WINDOWEVENT_LEAVE:
onMouseLeft(e);
break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
onKeyboardFocus(e);
break;
case SDL_WINDOWEVENT_FOCUS_LOST:
onKeyboardFocusLost(e);
break;
case SDL_WINDOWEVENT_CLOSE:
onWindowCloseRequest(e);
break;
default:
// Unexpected event type!
assert(0);
break;
}
}
Window::Window(int width, int height, const std::string & title) : width(width), height(height)
{
sdlWindow = SDL_CreateWindow(title.c_str(), SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, width, height,
SDL_WINDOW_OPENGL);
sdlWindowID = SDL_GetWindowID(sdlWindow);
sdlGLContext = SDL_GL_CreateContext(sdlWindow);
}
void ZWindow::PostClearUpEvent()
{
SDL_Event event;
event.type=SDL_USEREVENT;
event.user.code=SET_CLEAR_UP;
event.user.windowID=SDL_GetWindowID(m_win);
SDL_PushEvent(&event);
}
bool DKObject::WrongWindow(SDL_Event* event)
{
if(SDL_GetWindowID(win) != event->window.windowID){
return true;
}
return false;
}
SkOSWindow* SkOSWindow::GetInstanceForWindowID(Uint32 windowID) {
if (gCurrentWindow &&
gCurrentWindow->fWindow &&
SDL_GetWindowID(gCurrentWindow->fWindow) == windowID) {
return gCurrentWindow;
}
return nullptr;
}
/**
* @brief Window Creation and recreation.
*/
bool WindowManager::createWindow(bool fullScreen)
{
// If Window Already Exists, destory so we can recreate it.
if(m_window)
{
//std::cout << "Destroy SDL Window" << std::endl;
SDL_DestroyWindow(m_window);
m_window = nullptr;
}
int display_height = (m_height / 2);
int display_width = (m_width / 2);
// create window in in full screen or windowed mode.
if(fullScreen)
{
m_window = SDL_CreateWindow("EtherTerm 0.4.6 Alpha Demo - Full Screen",
(m_position_placement % 2 == 0) ? SDL_WINDOWPOS_CENTERED : display_width,
(m_position_placement % 2 == 0) ? SDL_WINDOWPOS_CENTERED : display_height,
m_width,
m_height,
SDL_WINDOW_SHOWN | SDL_WINDOW_FULLSCREEN_DESKTOP);
if(!m_window) // window init success
{
SDL_Log("Terminal::restartWindowSize() SDL_CreateWindow globalWindow: %s",
SDL_GetError());
assert(m_window);
}
}
else
{
m_window = SDL_CreateWindow("EtherTerm 0.4.6 Alpha Demo - Windowed",
(m_position_placement % 2 == 0) ? SDL_WINDOWPOS_CENTERED : display_width,
(m_position_placement % 2 == 0) ? SDL_WINDOWPOS_CENTERED : display_height,
m_width,
m_height,
SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
if(!m_window) // window init success
{
SDL_Log("Terminal::restartWindowSize() SDL_CreateWindow globalWindow: %s",
SDL_GetError());
assert(m_window);
}
}
// Set the Window ID
m_window_id = SDL_GetWindowID(m_window);
std::string title = "EtherTerm 0.4.6 Alpha Demo w/ Multiple Windows - Window ID: ";
title.append(std::to_string(m_window_id));
SDL_SetWindowTitle(m_window, title.c_str());
// Display and move focus to the new window.
SDL_ShowWindow(m_window);
SDL_RaiseWindow(m_window);
return true;
}
bool initPeripherals(void) {
// Init SDL
if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) != 0) {
printf("[FATAL]SDL could not initialize. SDL: %s\n", SDL_GetError());
return true;
}
SDL_version v;
SDL_GetVersion(&v);
printf("[INFO]SDL version %d.%d.%d\n", v.major, v.minor, v.patch);
// Init window
wndWidth = 480;
wndHeight = 360;
wnd = SDL_CreateWindow("Unofficial Scratch Project Player", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, wndWidth, wndHeight, SDL_WINDOW_SHOWN|SDL_WINDOW_RESIZABLE);
if(wnd == NULL) {
printf("[FATAL]SDL could not create new window. SDL: %s\n", SDL_GetError());
return true;
}
// Init OpenGL
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
//SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
//SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
gl = SDL_GL_CreateContext(wnd);
if(gl == NULL) {
printf("[FATAL]SDL could not create an OpenGL context. SDL: %s\n", SDL_GetError());
return true;
}
if(SDL_GL_SetSwapInterval(-1) != 0) {
printf("[NOTE]SDL could not enable late swap tearing. Trying vsync instead. SDL: %s\n", SDL_GetError());
if(SDL_GL_SetSwapInterval(1) != 0)
printf("[WARNING]SDL could not enable vsync: %s\n", SDL_GetError());
}
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
SDL_GL_SwapWindow(wnd);
// finish setting OpenGL options
//glEnable(GL_MULTISAMPLE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
wndID = SDL_GetWindowID(wnd);
hasFocus = true; hasMouse = true; windowIsShowing = true;
shouldQuit = false;
printf("[INFO]OpenGL: version %s ; glsl version %s ; vendor %s ; renderer %s\n", glGetString(GL_VERSION), glGetString(GL_SHADING_LANGUAGE_VERSION), glGetString(GL_VENDOR), glGetString(GL_RENDERER));
initGraphics();
//initAudio();
return false;
}
void I_GetEvent(void)
{
extern void I_HandleKeyboardEvent(SDL_Event *sdlevent);
extern void I_HandleMouseEvent(SDL_Event *sdlevent);
SDL_Event sdlevent;
SDL_PumpEvents();
while (SDL_PollEvent(&sdlevent))
{
switch (sdlevent.type)
{
case SDL_KEYDOWN:
if (ToggleFullScreenKeyShortcut(&sdlevent.key.keysym))
{
I_ToggleFullScreen();
break;
}
// deliberate fall-though
case SDL_KEYUP:
I_HandleKeyboardEvent(&sdlevent);
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
case SDL_MOUSEWHEEL:
if (usemouse && !nomouse && window_focused)
{
I_HandleMouseEvent(&sdlevent);
}
break;
case SDL_QUIT:
if (screensaver_mode)
{
I_Quit();
}
else
{
event_t event;
event.type = ev_quit;
D_PostEvent(&event);
}
break;
case SDL_WINDOWEVENT:
if (sdlevent.window.windowID == SDL_GetWindowID(screen))
{
HandleWindowEvent(&sdlevent.window);
}
break;
default:
break;
}
}
}
bool Window_mac::initWindow() {
if (fRequestedDisplayParams.fMSAASampleCount != fMSAASampleCount) {
this->closeWindow();
}
// we already have a window
if (fWindow) {
return true;
}
constexpr int initialWidth = 1280;
constexpr int initialHeight = 960;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
if (fRequestedDisplayParams.fMSAASampleCount > 1) {
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, fRequestedDisplayParams.fMSAASampleCount);
} else {
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
}
// TODO: handle other display params
uint32_t windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
fWindow = SDL_CreateWindow("SDL Window", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
initialWidth, initialHeight, windowFlags);
if (!fWindow) {
return false;
}
fMSAASampleCount = fRequestedDisplayParams.fMSAASampleCount;
// add to hashtable of windows
fWindowID = SDL_GetWindowID(fWindow);
gWindowMap.add(this);
fGLContext = SDL_GL_CreateContext(fWindow);
if (!fGLContext) {
SkDebugf("%s\n", SDL_GetError());
this->closeWindow();
return false;
}
return true;
}
void loop()
{
SDL_Event event;
int i;
int status;
/* Check for events */
++frames;
while (SDL_PollEvent(&event) && !done) {
switch (event.type) {
case SDL_WINDOWEVENT:
switch (event.window.event) {
case SDL_WINDOWEVENT_RESIZED:
for (i = 0; i < state->num_windows; ++i) {
if (event.window.windowID == SDL_GetWindowID(state->windows[i])) {
int w, h;
status = SDL_GL_MakeCurrent(state->windows[i], context[i]);
if (status) {
SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError());
break;
}
/* Change view port to the new window dimensions */
SDL_GL_GetDrawableSize(state->windows[i], &w, &h);
glViewport(0, 0, w, h);
state->window_w = event.window.data1;
state->window_h = event.window.data2;
/* Update window content */
Render(event.window.data1, event.window.data2, &datas[i]);
SDL_GL_SwapWindow(state->windows[i]);
break;
}
}
break;
}
}
SDLTest_CommonEvent(state, &event, &done);
}
if (!done) {
for (i = 0; i < state->num_windows; ++i) {
status = SDL_GL_MakeCurrent(state->windows[i], context[i]);
if (status) {
SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError());
/* Continue for next window */
continue;
}
Render(state->window_w, state->window_h, &datas[i]);
SDL_GL_SwapWindow(state->windows[i]);
}
}
#ifdef __EMSCRIPTEN__
else {
emscripten_cancel_main_loop();
}
#endif
}
bool gl_set_video_mode(struct graphics_data *graphics, int width, int height,
int depth, bool fullscreen, bool resize)
{
struct sdl_render_data *render_data = graphics->render_data;
#if SDL_VERSION_ATLEAST(2,0,0)
SDL_GLContext context;
render_data->window = SDL_CreateWindow("MegaZeux",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height,
GL_STRIP_FLAGS(sdl_flags(depth, fullscreen, resize)));
if(!render_data->window)
{
warn("Failed to create window: %s\n", SDL_GetError());
return false;
}
render_data->renderer =
SDL_CreateRenderer(render_data->window, -1, SDL_RENDERER_ACCELERATED);
if(!render_data->renderer)
{
warn("Failed to create renderer: %s\n", SDL_GetError());
return false;
}
context = SDL_GL_CreateContext(render_data->window);
if(!context)
{
warn("Failed to create context: %s\n", SDL_GetError());
return false;
}
if(SDL_GL_MakeCurrent(render_data->window, context))
{
warn("Failed to make context current: %s\n", SDL_GetError());
return false;
}
sdl_window_id = SDL_GetWindowID(render_data->window);
#else // !SDL_VERSION_ATLEAST(2,0,0)
if(!SDL_SetVideoMode(width, height, depth,
GL_STRIP_FLAGS(sdl_flags(depth, fullscreen, resize))))
return false;
#endif // !SDL_VERSION_ATLEAST(2,0,0)
render_data->screen = NULL;
render_data->shadow = NULL;
return true;
}
virtual bool initSDL(int x, int y, int w, int h, std::string wtitle, Uint32 flags)
{
bool success = true;
mTitle = wtitle;
//Set the scaling quality to nearest-pixel
if (SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0") < 0)
{
success = false;
logger().error() << "Error: Failed to set Render Scale Quality" << logs::end;
return success;
}
//Create window
mWindow = SDL_CreateWindow(mTitle.c_str(), x, y, w, h, flags);
if (mWindow != NULL)
{
mMouseFocus = true;
mKeyboardFocus = true;
mWidth = w;
mHeight = h;
//Create renderer for window
mRenderer = SDL_CreateRenderer(mWindow, -1,
SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (mRenderer == NULL)
{
logger().error() << "Error: Renderer could not be created! SDL Error: "
<< SDL_GetError() << logs::end;
SDL_DestroyWindow(mWindow);
mWindow = NULL;
success = false;
return success;
}
else
{
//Grab window identifier
mWindowID = SDL_GetWindowID(mWindow);
//Flag as opened
mShown = true;
}
}
else
{
success = false;
logger().error() << "Error: Window could not be created! SDL Error: " << SDL_GetError()
<< logs::end;
return success;
}
logger().debug() << "Window initSDL => ID= " << mWindowID << logs::end;
return success;
}
int main(int argc, char **argv)
{
init_sdl(&Render_Context::sdlWindow, &Render_Context::sdlRenderer,
&Render_Context::sdlTexture, &Render_Context::screen, SCREEN_WIDTH, SCREEN_HEIGHT);
Render_Context::windowID = SDL_GetWindowID(Render_Context::sdlWindow);
//SDL_SetWindowSize(Render_Context::sdlWindow, 1024+100, 768+100);
//fprintf(stderr, "screen = %d\n", Render_Context::screen);
App app(argc, argv, 32000);
app.run();
}
ALLEGRO_DISPLAY *_al_sdl_find_display(uint32_t window_id) {
unsigned int i;
ALLEGRO_SYSTEM *s = al_get_system_driver();
for (i = 0; i < _al_vector_size(&s->displays); i++) {
void **v = (void **)_al_vector_ref(&s->displays, i);
ALLEGRO_DISPLAY_SDL *d = *v;
if (SDL_GetWindowID(d->window) == window_id) {
return &d->display;
break;
}
}
return NULL;
}
void RenderBlock::initializeRenderer(SDL_Window *window) {
_renderer = SDL_CreateRenderer(window, -1,
SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (!_renderer)
emit error("SDL_CreateRenderer error: ");
_windowId = SDL_GetWindowID(window);
// autoscaling
SDL_Window *w = SDL_GetWindowFromID(_windowId);
int x, y;
SDL_GetWindowSize(w, &x, &y);
SDL_RenderSetLogicalSize(_renderer, x, y);
}
void Client::HandleEvent (const SDL_Event *event)
{
// The only event that the client handles himself is SDL_QUIT
// The rest is passed on to the current scene.
Uint32 windowID = SDL_GetWindowID (mainWindow);
switch(event->type) {
case SDL_QUIT:
ShutDown ();
break;
case SDL_WINDOWEVENT:
if (event->window.windowID != windowID)
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
if (event->key.windowID != windowID)
break;
case SDL_TEXTINPUT:
if (event->text.windowID != windowID)
break;
case SDL_TEXTEDITING:
if (event->edit.windowID != windowID)
break;
case SDL_MOUSEWHEEL:
if (event->wheel.windowID != windowID)
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
if (event->button.windowID != windowID)
break;
case SDL_MOUSEMOTION:
if (event->motion.windowID != windowID)
break;
default:
if (pScene)
pScene -> OnEvent (event);
break;
} // End switch
}
void ApplicationContextSDL::pollEvents()
{
if(mWindows.empty())
{
// SDL events not initialized
return;
}
SDL_Event event;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_QUIT:
mRoot->queueEndRendering();
break;
case SDL_WINDOWEVENT:
if(event.window.event != SDL_WINDOWEVENT_RESIZED)
continue;
for(WindowList::iterator it = mWindows.begin(); it != mWindows.end(); ++it)
{
if(event.window.windowID != SDL_GetWindowID(it->native))
continue;
Ogre::RenderWindow* win = it->render;
win->windowMovedOrResized();
windowResized(win);
}
break;
default:
_fireInputEvent(convert(event), event.window.windowID);
break;
}
}
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
// hacky workaround for black window on OSX
for(const auto& win : mWindows)
{
SDL_SetWindowSize(win.native, win.render->getWidth(), win.render->getHeight());
win.render->windowMovedOrResized();
}
#endif
}
//--------------------------------------------
// --
//--------------------------------------------
void Machine::HandleEvent(SDL_Event& _event)
{
if (_event.window.windowID != SDL_GetWindowID(mWindow))
return;
switch(_event.type)
{
case SDL_KEYDOWN:
{
Joypad& joypad = mGb.GetJoypad();
switch(_event.key.keysym.sym)
{
case SDLK_UP: joypad.OnKeyDown(Joypad::Key::Up); break;
case SDLK_DOWN: joypad.OnKeyDown(Joypad::Key::Down); break;
case SDLK_LEFT: joypad.OnKeyDown(Joypad::Key::Left); break;
case SDLK_RIGHT: joypad.OnKeyDown(Joypad::Key::Right); break;
case SDLK_a: joypad.OnKeyDown(Joypad::Key::A); break;
case SDLK_s: joypad.OnKeyDown(Joypad::Key::B); break;
case SDLK_LSHIFT: joypad.OnKeyDown(Joypad::Key::Select); break;
case SDLK_RETURN: joypad.OnKeyDown(Joypad::Key::Start); break;
}
}
break;
case SDL_KEYUP:
{
Joypad& joypad = mGb.GetJoypad();
switch (_event.key.keysym.sym)
{
case SDLK_UP: joypad.OnKeyUp(Joypad::Key::Up); break;
case SDLK_DOWN: joypad.OnKeyUp(Joypad::Key::Down); break;
case SDLK_LEFT: joypad.OnKeyUp(Joypad::Key::Left); break;
case SDLK_RIGHT: joypad.OnKeyUp(Joypad::Key::Right); break;
case SDLK_a: joypad.OnKeyUp(Joypad::Key::A); break;
case SDLK_s: joypad.OnKeyUp(Joypad::Key::B); break;
case SDLK_LSHIFT: joypad.OnKeyUp(Joypad::Key::Select); break;
case SDLK_RETURN: joypad.OnKeyUp(Joypad::Key::Start); break;
}
}
break;
}
}
bool Window::init()
{
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
std::cout << "Failed to init SDL\n";
return false;
}
m_Window.reset(SDL_CreateWindow(m_Title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, m_Width, m_Height, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE));
if (!m_Window)
{
std::cout << "Failed to create Window\n";
return false;
}
m_Context = SDL_GL_CreateContext(m_Window.get());
m_WindowId = SDL_GetWindowID(m_Window.get());
#ifdef __APPLE__
// "Magic incantation" for getting an OpenGL 3.2 context with SDL2 on Mac OS X
// See: http://stackoverflow.com/questions/11961116/opengl-3-x-context-creation-using-sdl2-on-osx-macbook-air-2012
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
#endif
#ifndef __APPLE__
auto status=glewInit();
if (status!= GLEW_OK)
{
std::cout << "Failed to initialize glew\n";
std::cout << glewGetErrorString(status) << "\n";
return false;
}
#endif
std::cout << "OpenGL " << glGetString(GL_VERSION) << "\n";
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
return true;
}
int SDL_DUMMY_UpdateWindowFramebuffer(_THIS, SDL_Window * window, const SDL_Rect * rects, int numrects)
{
static int frame_number;
SDL_Surface *surface;
surface = (SDL_Surface *) SDL_GetWindowData(window, DUMMY_SURFACE);
if (!surface) {
return SDL_SetError("Couldn't find dummy surface for window");
}
/* Send the data to the display */
if (SDL_getenv("SDL_VIDEO_DUMMY_SAVE_FRAMES")) {
char file[128];
SDL_snprintf(file, sizeof(file), "SDL_window%d-%8.8d.bmp",
SDL_GetWindowID(window), ++frame_number);
SDL_SaveBMP(surface, file);
}
return 0;
}
