// 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);
}
