// Set's up what our program will be using void setup(Matrix &projectionMatrix, Matrix &viewMatrix, Matrix &modelMatrix){ SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("My Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 360, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); #ifdef _WINDOWS glewInit(); #endif }
/* ================= GL_UpdateContext ================= */ qboolean GL_UpdateContext( void ) { if(!( SDL_GL_MakeCurrent( host.hWnd, glw_state.context ) ) ) { MsgDev(D_ERROR, "GL_UpdateContext: %s", SDL_GetError()); return GL_DeleteContext(); } return true; }
static void _PlatformCreateOpenGLContextCore(FPlatformOpenGLContext* OutContext) { check(OutContext); SDL_HWindow PrevWindow = SDL_GL_GetCurrentWindow(); SDL_HGLContext PrevContext = SDL_GL_GetCurrentContext(); OutContext->hGLContext = SDL_GL_CreateContext(OutContext->hWnd); SDL_GL_MakeCurrent(PrevWindow, PrevContext); }
void android_egl_context_backup() { /* Keep a copy of the EGL Context so we can try to restore it when we resume */ SDL_WindowData *data = (SDL_WindowData *) Android_Window->driverdata; data->egl_context = SDL_GL_GetCurrentContext(); /* We need to do this so the EGLSurface can be freed */ SDL_GL_MakeCurrent(Android_Window, NULL); }
void CGfxLibrary::PlatformEndDriver_OGL(void) { // shut the driver down SDL_GL_MakeCurrent(NULL, NULL); if (go_hglRC) { SDL_GL_DeleteContext(go_hglRC); go_hglRC = NULL; } }
internal b32 SetupSDLWindow(GameState * CurrentGameState) { if(CurrentGameState->ScreenWidth == 0) { CurrentGameState->ScreenWidth = DEFAULT_SCREEN_WIDTH; } if(CurrentGameState->ScreenHeight == 0) { CurrentGameState->ScreenHeight = DEFAULT_SCREEN_HEIGHT; } 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_DEPTH_SIZE, 24); CurrentGameState->MainSDLWindow = SDL_CreateWindow("TA_SDL: SOMETHING HERE!!!", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,CurrentGameState->ScreenWidth, CurrentGameState->ScreenHeight, SDL_WINDOW_SHOWN|SDL_WINDOW_OPENGL); if (!CurrentGameState->MainSDLWindow) { LogError("SDL_CreateWindow Error: %s", SDL_GetError()); return 0; } CurrentGameState->PerformanceCounterFrequency = SDL_GetPerformanceFrequency(); Assert(CurrentGameState->PerformanceCounterFrequency); GLint GLMajorVer, GLMinorVer; CurrentGameState->glContext = SDL_GL_CreateContext( CurrentGameState->MainSDLWindow); SDL_GL_MakeCurrent (CurrentGameState->MainSDLWindow,CurrentGameState->glContext); if( SDL_GL_SetSwapInterval( 1 ) < 0 ) { LogWarning("Warning: Unable to set VSync! SDL Error: %s",SDL_GetError()); } glGetIntegerv(GL_MAJOR_VERSION, &GLMajorVer); glGetIntegerv(GL_MINOR_VERSION, &GLMinorVer); GLenum ErrorValue = glGetError(); if(ErrorValue!=GL_NO_ERROR) { LogError("failed before glewInit : %s",gluErrorString(ErrorValue)); } //as we need to use glewExperimental - known issue (it segfaults otherwise!) - we encounter //another known issue, which is that while glewInit suceeds, it leaves opengl in an error state ErrorValue = glGetError(); return 1; }
void ClassDemoApp::Setup() { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("My Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 360, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); #ifdef _WINDOWS glewInit(); #endif done = false; srand((unsigned int)time(NULL)); program = new ShaderProgram(RESOURCE_FOLDER"vertex_textured.glsl", RESOURCE_FOLDER"fragment_textured.glsl"); // program = new ShaderProgram(RESOURCE_FOLDER"vertex.glsl", RESOURCE_FOLDER"fragment.glsl"); tileTexture = LoadTexture("sheet_4.png"); projectionMatrix.setOrthoProjection(-3.55f, 3.55f, -2.0f, 2.0f, -1.0f, 1.0f); //SheetSprite sheet = SheetSprite(tileTexture, 14, 8); for (int i = 0; i < LEVEL_HEIGHT; i++) { for (int j = 0; j < LEVEL_WIDTH; j++) { if (i == 0 || j == 0 || j == LEVEL_WIDTH - 1) levelData[i][j] = 13; else levelData[i][j] = 254; } } for (int k = 2; k < LEVEL_WIDTH - 5; ) { for (int r = rand() % 3; r < 3; r++) { int j = rand() % (LEVEL_HEIGHT - 4) + 3; for (int i = rand() % 4; i < 6; i++) { levelData[j][k + i] = 13; if (i == 4 && (k + i) > LEVEL_WIDTH - 11) { levelData[j - 1][k + i] = 64; r = 3; } } } k += 7 + rand() % 3; } SheetSprite playerSprite = SheetSprite(LoadTexture("p2_spritesheet.png"), 1, 1); player = new Entity(playerSprite); entities.push_back(player); player->width = 0.225f; player->height = 0.3f; player->x = TILE_SIZE * 6 + player->width / 2; player->y = -TILE_SIZE * 2; player->isStatic = false; baseTouchX = 6; }
GHOST_TSuccess GHOST_WindowSDL::activateDrawingContext() { if (m_sdl_glcontext != NULL) { int status = SDL_GL_MakeCurrent(m_sdl_win, m_sdl_glcontext); (void)status; return GHOST_kSuccess; } return GHOST_kFailure; }
int sdl2_gl_make_context_current(DisplayChangeListener *dcl, QEMUGLContext ctx) { struct sdl2_console *scon = container_of(dcl, struct sdl2_console, dcl); SDL_GLContext sdlctx = (SDL_GLContext)ctx; assert(scon->opengl); return SDL_GL_MakeCurrent(scon->real_window, sdlctx); }
bool Window::glMakeCurrent() noexcept { if ( m_wimpl->glcontext == nullptr ) { lx::setError( "The current window is not an OpenGL window" ); return false; } return SDL_GL_MakeCurrent( m_wimpl->window, m_wimpl->glcontext ) == 0; }
void android_egl_context_restore() { SDL_WindowData *data = (SDL_WindowData *) Android_Window->driverdata; // Clockwork: make sure there is a valid stored context to restore if (data->egl_context && SDL_GL_MakeCurrent(Android_Window, (SDL_GLContext) data->egl_context) < 0) { // Clockwork: if the old context could not be restored, leave it to the Graphics subsystem to create a new one data->egl_context = NULL; } }
void PlatKillas::Init() { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("My Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); glViewport(0, 0, 800, 600); glMatrixMode(GL_PROJECTION); glOrtho(-1.33, 1.33, -1.0, 1.0, -1.0, 1.0); }
bool GraphicsWindowSDL2::releaseContextImplementation() { if(!mRealized) { OSG_WARN<< "Warning: GraphicsWindow not realized, cannot do releaseContext." <<std::endl; return false; } return SDL_GL_MakeCurrent(NULL, NULL)==0; }
void SDLGraphicsOperations::makeOpenGLContextCurrent(os::OpenGLContext* ctx) { if (ctx == nullptr) { SDL_GL_MakeCurrent(os_get_window(), nullptr); } else { reinterpret_cast<SDLOpenGLContext*>(ctx)->makeCurrent(); } }
bool GraphicsWindowSDL2::makeCurrentImplementation() { if(!mRealized) { OSG_WARN<<"Warning: GraphicsWindow not realized, cannot do makeCurrent."<<std::endl; return false; } return SDL_GL_MakeCurrent(mWindow, mContext)==0; }
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; }
void Asteroids::Init() { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("My Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 4096); glViewport(0, 0, 800, 600); glMatrixMode(GL_PROJECTION); glOrtho(-1.33, 1.33, -1.0, 1.0, -1.0, 1.0); }
/* ** GLimp_SharedContext_Create */ bool GLimp_SharedContext_Create( void **context, void **surface ) { SDL_GL_SetAttribute( SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1 ); *context = (void*)SDL_GL_CreateContext( glw_state.sdl_window ); *surface = NULL; // SDL_GL_CreateContext makes the newly created context current // we don't want that, so revert to our main context return SDL_GL_MakeCurrent( glw_state.sdl_window, glw_state.sdl_glcontext ) == 0; }
void Window::MakeCurrent() { if(window_) { SDL_GL_MakeCurrent(window_, context_); } else { assert(window_); } }
void sdl2_gl_update(DisplayChangeListener *dcl, int x, int y, int w, int h) { struct sdl2_console *scon = container_of(dcl, struct sdl2_console, dcl); assert(scon->opengl); SDL_GL_MakeCurrent(scon->real_window, scon->winctx); surface_gl_update_texture(scon->gls, scon->surface, x, y, w, h); scon->updates++; }
MStatus RadiosityRenderer::doIt(const MArgList &args) { this->args = args; windowWidth = 640; windowHeight = 480; SDL_Window *window = SDL_CreateWindow( "Radiosity Renderer Viewport", 0, 0, 640, 480, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE ); SDL_GLContext glcontext = SDL_GL_CreateContext(window); glClearColor(0,0,0,1); glClear(GL_COLOR_BUFFER_BIT); M3dView curView = M3dView::active3dView(); MDagPath camDagPath; curView.getCamera( camDagPath ); IterateThroughDag(); //Pass DAG to renderer, let renderer render scene... SDL_GL_MakeCurrent(window, glcontext); GLRenderer renderer = GLRenderer(640,480); renderer.RenderToScreen(); SDL_GL_SwapWindow(window); //Write pixels to render window... prepareRenderView(); SDL_GL_MakeCurrent(window, glcontext); renderBufferToRenderView(); sleep(1); SDL_GL_DeleteContext(glcontext); SDL_DestroyWindow(window); SDL_Quit(); return MS::kSuccess; }
void Setup(SDL_Window** displayWindow,Matrix* projectionMatrix){ SDL_Init(SDL_INIT_VIDEO); *displayWindow = SDL_CreateWindow("Pong", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 360, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(*displayWindow); SDL_GL_MakeCurrent(*displayWindow, context); #ifdef _WINDOWS glewInit(); #endif glViewport(0, 0, 640, 360); projectionMatrix->setOrthoProjection(-3.55, 3.55, -2.0f, 2.0f, -1.0f, 1.0f); }
void WindowSDL2::render() { if(closed) { return; } if(this != current_gl_window) { current_gl_window = this; SDL_GL_MakeCurrent(window, snow_gl_context); } } //render
void Game::Init() { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("LaupsyGame", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); glViewport(0, 0, 800, 600); glMatrixMode(GL_MODELVIEW); Bullet bullet(0.05f,10.0f,0.0f,0.0f); bullets.push_back(bullet); }
ShaderProgram setup() { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("Assignment 2 - Sergey Smirnov", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); #ifdef _WINDOWS glewInit(); #endif glViewport(0, 0, 1280, 720); return ShaderProgram(RESOURCE_FOLDER"vertex_textured.glsl", RESOURCE_FOLDER"fragment_textured.glsl"); }
int main(int argc, char *argv[]) { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("My Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 360, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); #ifdef _WINDOWS glewInit(); #endif glViewport(0, 0, 640, 360); srand(time(0)); ShaderProgram program(RESOURCE_FOLDER"vertex_textured.glsl", RESOURCE_FOLDER"fragment_textured.glsl"); Matrix projectionMatrix; Matrix modelMatrix; Matrix viewMatrix; projectionMatrix.setOrthoProjection(-3.55f, 3.55f, -2.0f, 2.0f, -1.0f, 1.0f); //Setup(program, projectionMatrix); //Animation, Matrix, and Entitys variables initializeEntities(); //enable blending glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); while (!done) { ticks = (float)SDL_GetTicks() / 1000.0f; elapsed = ticks - lastFrameTicks; lastFrameTicks = ticks; ProcessEvents(); glUseProgram(program.programID); //p1Entity.Update(elapsed); setBackgroundColorAndClear(); program.setModelMatrix(modelMatrix); program.setViewMatrix(viewMatrix); program.setProjectionMatrix(projectionMatrix); Update(lastFrameTicks, modelMatrix, program); Render(program, modelMatrix); SDL_GL_SwapWindow(displayWindow); } SDL_Quit(); return 0; }
int main(int argc, char *argv[]) { SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("Assignment 1", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 360, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); #ifdef _WINDOWS glewInit(); #endif SDL_Event event; bool done = false; //size and pixel offset glViewport(0, 0, 640, 360); ShaderProgram program(RESOURCE_FOLDER"vertex_textured.glsl", RESOURCE_FOLDER"fragment_textured.glsl"); GLuint player = LoadTexture("assets/alien_sheet.png", GL_RGB); Matrix projectionMatrix; Matrix modelMatrix; Matrix viewMatrix; //projection matrix projectionMatrix.setOrthoProjection(-3.55f, 3.55f, -2.0f, 2.0f, -1.0f, 1.0f); float lastFrameTicks = 0.0f; while (!done) { while (SDL_PollEvent(&event)) { if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) { done = true; } } //tick tick tick float ticks = (float)SDL_GetTicks() / 1000.0f; float elapsed = ticks - lastFrameTicks; lastFrameTicks = ticks; glClear(GL_COLOR_BUFFER_BIT); //drawing draw(program, modelMatrix, projectionMatrix, viewMatrix, player); glDisableClientState(GL_VERTEX_ARRAY); SDL_GL_SwapWindow(displayWindow); } SDL_Quit(); return 0; }
void init() { // Initialize SDL SDL_Init(SDL_INIT_VIDEO); displayWindow = SDL_CreateWindow("Homework 3 - Space Invaders", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, SDL_WINDOW_OPENGL); SDL_GLContext context = SDL_GL_CreateContext(displayWindow); SDL_GL_MakeCurrent(displayWindow, context); #ifdef _WINDOWS glewInit(); #endif glViewport(0, 0, 640, 480); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); }
bool beginRendering(window w) { #ifdef OXYGINE_SDL SDL_Window *wnd = w; if (!wnd) wnd = _window; SDL_GL_MakeCurrent(wnd, _context); #endif CHECKGL(); return Renderer::isReady(); }
static void sdl2_gl_render_surface(struct sdl2_console *scon) { int ww, wh; SDL_GL_MakeCurrent(scon->real_window, scon->winctx); sdl2_set_scanout_mode(scon, false); SDL_GetWindowSize(scon->real_window, &ww, &wh); surface_gl_setup_viewport(scon->gls, scon->surface, ww, wh); surface_gl_render_texture(scon->gls, scon->surface); SDL_GL_SwapWindow(scon->real_window); }