int bmx_SDL_RenderSetViewport(SDL_Renderer * renderer, int x, int y, int w, int h) { if (x < 0 || y < 0 || w < 0 || h < 0) { return SDL_RenderSetViewport(renderer, 0); } else { SDL_Rect r = { x, y, w, h }; return SDL_RenderSetViewport(renderer, &r); } }
static void VL_SDL2_Present(void *surface, int scrlX, int scrlY) { // TODO: Verify this is a VL_SurfaceUsage_FrontBuffer VL_SDL2_ResizeWindow(); SDL_Surface *surf = (SDL_Surface *)surface; SDL_Rect srcr = {(Sint16)scrlX, (Sint16)scrlY, VL_EGAVGA_GFX_WIDTH, VL_EGAVGA_GFX_HEIGHT}; SDL_Rect integerRect = {0, 0, vl_integerWidth, vl_integerHeight}; SDL_Rect renderRect = {(Sint16)vl_renderRgn_x, (Sint16)vl_renderRgn_y, vl_renderRgn_w, vl_renderRgn_h}; SDL_Rect fullRect = {(Sint16)vl_fullRgn_x, (Sint16)vl_fullRgn_y, vl_fullRgn_w, vl_fullRgn_h}; SDL_BlitSurface(surf, &srcr, vl_sdl2_stagingSurface, 0); SDL_UpdateTexture(vl_sdl2_texture, 0, vl_sdl2_stagingSurface->pixels, vl_sdl2_stagingSurface->pitch); SDL_SetRenderTarget(vl_sdl2_renderer, vl_sdl2_scaledTarget); SDL_SetRenderDrawColor(vl_sdl2_renderer, VL_EGARGBColorTable[vl_emuegavgaadapter.bordercolor][0], VL_EGARGBColorTable[vl_emuegavgaadapter.bordercolor][1], VL_EGARGBColorTable[vl_emuegavgaadapter.bordercolor][2], 255); SDL_RenderClear(vl_sdl2_renderer); SDL_RenderCopy(vl_sdl2_renderer, vl_sdl2_texture, 0, &renderRect); SDL_SetRenderTarget(vl_sdl2_renderer, 0); SDL_SetRenderDrawColor(vl_sdl2_renderer, 0, 0, 0, 255); SDL_RenderClear(vl_sdl2_renderer); SDL_RenderSetViewport(vl_sdl2_renderer, 0); SDL_RenderCopy(vl_sdl2_renderer, vl_sdl2_scaledTarget, 0, &fullRect); SDL_RenderPresent(vl_sdl2_renderer); }
void Render_SW_SDL::resetViewport() { float w, w1, h, h1; int wi, hi; SDL_GetWindowSize(PGE_Window::window, &wi, &hi); w=wi; h=hi; w1=w; h1=h; scale_x=(float)((float)(w)/(float)window_w); scale_y=(float)((float)(h)/(float)window_h); viewport_scale_x = scale_x; viewport_scale_y = scale_y; if(scale_x>scale_y) { w1=scale_y*window_w; viewport_scale_x=w1/window_w; } else if(scale_x<scale_y) { h1=scale_x*window_h; viewport_scale_y=h1/window_h; } offset_x=(w-w1)/2; offset_y=(h-h1)/2; //glViewport(offset_x, offset_y, (GLsizei)w1, (GLsizei)h1); GLERRORCHECK(); SDL_Rect topLeftViewport; topLeftViewport.x = offset_x; topLeftViewport.y = offset_y; topLeftViewport.w = w1; topLeftViewport.h = h1; SDL_RenderSetViewport( m_gRenderer, &topLeftViewport ); setViewportSize(window_w, window_h); }
static int SDL_RendererEventWatch(void *userdata, SDL_Event *event) { SDL_Renderer *renderer = (SDL_Renderer *)userdata; if (event->type == SDL_WINDOWEVENT) { SDL_Window *window = SDL_GetWindowFromID(event->window.windowID); if (window == renderer->window) { if (renderer->WindowEvent) { renderer->WindowEvent(renderer, &event->window); } if (event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) { /* Try to keep the previous viewport centered */ int w, h; SDL_Rect viewport; SDL_GetWindowSize(window, &w, &h); viewport.x = (w - renderer->viewport.w) / 2; viewport.y = (h - renderer->viewport.h) / 2; viewport.w = renderer->viewport.w; viewport.h = renderer->viewport.h; SDL_RenderSetViewport(renderer, &viewport); } else if (event->window.event == SDL_WINDOWEVENT_MINIMIZED) { renderer->minimized = SDL_TRUE; } else if (event->window.event == SDL_WINDOWEVENT_RESTORED) { renderer->minimized = SDL_FALSE; } } } return 0; }
//renderizar void ViewPort::render() { //renderizamos en el viewport seleccionado SDL_RenderSetViewport( gRenderer, ¶m ); //Render texture to screen tex.render(gRenderer, &tamañofin); }
static int UpdateLogicalSize(SDL_Renderer *renderer) { int w, h; float want_aspect; float real_aspect; float scale; SDL_Rect viewport; if (SDL_GetRendererOutputSize(renderer, &w, &h) < 0) { return -1; } want_aspect = (float)renderer->logical_w / renderer->logical_h; real_aspect = (float)w / h; /* Clear the scale because we're setting viewport in output coordinates */ SDL_RenderSetScale(renderer, 1.0f, 1.0f); if (SDL_fabs(want_aspect-real_aspect) < 0.0001) { /* The aspect ratios are the same, just scale appropriately */ scale = (float)w / renderer->logical_w; SDL_RenderSetViewport(renderer, NULL); } else if (want_aspect > real_aspect) { /* We want a wider aspect ratio than is available - letterbox it */ scale = (float)w / renderer->logical_w; viewport.x = 0; viewport.w = w; viewport.h = (int)SDL_ceil(renderer->logical_h * scale); viewport.y = (h - viewport.h) / 2; SDL_RenderSetViewport(renderer, &viewport); } else { /* We want a narrower aspect ratio than is available - use side-bars */ scale = (float)h / renderer->logical_h; viewport.y = 0; viewport.h = h; viewport.w = (int)SDL_ceil(renderer->logical_w * scale); viewport.x = (w - viewport.w) / 2; SDL_RenderSetViewport(renderer, &viewport); } /* Set the new scale */ SDL_RenderSetScale(renderer, scale, scale); return 0; }
void Menu::renderizar() { SDL_RenderSetViewport(renderer_principal, &vista_juego); // Renderizar botones for (int i = 0; i < NUM_BOTONES; i++) { botones[i]->renderizar(); } }
static void sdl_refresh_renderer(sdl2_video_t *vid) { SDL_RenderClear(vid->renderer); SDL_Rect r = { vid->vp.x, vid->vp.y, (int)vid->vp.width, (int)vid->vp.height }; SDL_RenderSetViewport(vid->renderer, &r); // breaks int scaling // SDL_RenderSetLogicalSize(vid->renderer, vid->vp.width, vid->vp.height); }
void loop() { SDL_Event event; while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_WINDOWEVENT: if (event.window.event == SDL_WINDOWEVENT_RESIZED) { SDL_RenderSetViewport(renderer, NULL); displayrect.w = window_w = event.window.data1; displayrect.h = window_h = event.window.data2; } break; case SDL_MOUSEBUTTONDOWN: displayrect.x = event.button.x - window_w / 2; displayrect.y = event.button.y - window_h / 2; break; case SDL_MOUSEMOTION: if (event.motion.state) { displayrect.x = event.motion.x - window_w / 2; displayrect.y = event.motion.y - window_h / 2; } break; case SDL_KEYDOWN: if (event.key.keysym.sym == SDLK_SPACE) { paused = !paused; break; } if (event.key.keysym.sym != SDLK_ESCAPE) { break; } case SDL_QUIT: done = SDL_TRUE; break; } } #ifndef __EMSCRIPTEN__ SDL_Delay(fpsdelay); #endif if (!paused) { i = (i + 1) % MOOSEFRAMES_COUNT; SDL_UpdateTexture(MooseTexture, NULL, MooseFrame[i], MOOSEPIC_W*SDL_BYTESPERPIXEL(pixel_format)); } SDL_RenderClear(renderer); SDL_RenderCopy(renderer, MooseTexture, NULL, &displayrect); SDL_RenderPresent(renderer); #ifdef __EMSCRIPTEN__ if (done) { emscripten_cancel_main_loop(); } #endif }
int main(int argc, char **args) { SDL_Event e; bool quit = false; if (init() && loadMedia()) { while (!quit) { while (SDL_PollEvent(&e) != 0) { if (e.type == SDL_QUIT) { quit = true; } } SDL_Rect topLeftViewport; topLeftViewport.x = 0; topLeftViewport.y = 0; topLeftViewport.w = SCREEN_WIDTH / 2; topLeftViewport.h = SCREEN_HEIGHT / 2; SDL_Rect topRightViewport; topRightViewport.x = SCREEN_WIDTH / 2; topRightViewport.y = 0; topRightViewport.w = SCREEN_WIDTH / 2; topRightViewport.h = SCREEN_HEIGHT / 2; SDL_Rect bottomViewport; bottomViewport.x = 0; bottomViewport.y = SCREEN_HEIGHT / 2; bottomViewport.w = SCREEN_WIDTH; bottomViewport.h = SCREEN_HEIGHT / 2; SDL_RenderSetViewport(renderer, &topLeftViewport); SDL_RenderCopy(renderer, texture, NULL, NULL); SDL_RenderSetViewport(renderer, &topRightViewport); SDL_RenderCopy(renderer, texture, NULL, NULL); SDL_RenderSetViewport(renderer, &bottomViewport); SDL_RenderCopy(renderer, texture, NULL, NULL); SDL_RenderPresent(renderer); } } return 0; }
int SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture) { SDL_Rect viewport; if (!SDL_RenderTargetSupported(renderer)) { SDL_Unsupported(); return -1; } if (texture == renderer->target) { /* Nothing to do! */ return 0; } /* texture == NULL is valid and means reset the target to the window */ if (texture) { CHECK_TEXTURE_MAGIC(texture, -1); if (renderer != texture->renderer) { SDL_SetError("Texture was not created with this renderer"); return -1; } if (!(texture->access & SDL_TEXTUREACCESS_TARGET)) { SDL_SetError("Texture not created with SDL_TEXTUREACCESS_TARGET"); return -1; } if (texture->native) { /* Always render to the native texture */ texture = texture->native; } } if (texture && !renderer->target) { /* Make a backup of the viewport */ renderer->viewport_backup = renderer->viewport; } renderer->target = texture; if (renderer->SetRenderTarget(renderer, texture) < 0) { return -1; } if (texture) { viewport.x = 0; viewport.y = 0; viewport.w = texture->w; viewport.h = texture->h; } else { viewport = renderer->viewport_backup; } if (SDL_RenderSetViewport(renderer, &viewport) < 0) { return -1; } /* All set! */ return 0; }
void Render_SW_SDL::setViewport(int x, int y, int w, int h) { SDL_Rect topLeftViewport; topLeftViewport.x = offset_x + (int)ceil((float)x*viewport_scale_x); topLeftViewport.y = offset_y + (int)ceil((float)y*viewport_scale_y); topLeftViewport.w = (int)round((float)w*viewport_scale_x); topLeftViewport.h = (int)round((float)h*viewport_scale_y); SDL_RenderSetViewport( m_gRenderer, &topLeftViewport ); viewport_x=(float)x; viewport_y=(float)y; setViewportSize(w, h); }
void SDLRenderer::apply_viewport() { Size target_size = (g_config->use_fullscreen && g_config->fullscreen_size != Size(0, 0)) ? g_config->fullscreen_size : g_config->window_size; float pixel_aspect_ratio = 1.0f; if (g_config->aspect_size != Size(0, 0)) { pixel_aspect_ratio = calculate_pixel_aspect_ratio(m_desktop_size, g_config->aspect_size); } else if (g_config->use_fullscreen) { pixel_aspect_ratio = calculate_pixel_aspect_ratio(m_desktop_size, target_size); } // calculate the viewport Size max_size(1280, 800); Size min_size(640, 480); Size logical_size; calculate_viewport(min_size, max_size, target_size, pixel_aspect_ratio, g_config->magnification, m_scale, logical_size, m_viewport); SCREEN_WIDTH = logical_size.width; SCREEN_HEIGHT = logical_size.height; if (m_viewport.x != 0 || m_viewport.y != 0) { // Clear the screen to avoid garbage in unreachable areas after we // reset the coordinate system SDL_SetRenderDrawColor(m_renderer, 0, 0, 0, 255); SDL_SetRenderDrawBlendMode(m_renderer, SDL_BLENDMODE_NONE); SDL_RenderClear(m_renderer); SDL_RenderPresent(m_renderer); SDL_RenderClear(m_renderer); } // SetViewport() works in scaled screen coordinates, so we have to // reset it to 1.0, 1.0 to get meaningful results SDL_RenderSetScale(m_renderer, 1.0f, 1.0f); SDL_RenderSetViewport(m_renderer, &m_viewport); SDL_RenderSetScale(m_renderer, m_scale.x, m_scale.y); }
void Window::updateViewportPosition(s16 x, s16 y) { // Check if the viewport is in the map if(x < 0) x = 0; if(x + m_viewportW >= MapManager::currentMap->width() * 16) x = MapManager::currentMap->width() * 16 - m_viewportW - 1; if(y < 0) y = 0; if(y + m_viewportH >= MapManager::currentMap->height() * 16) y = MapManager::currentMap->height() * 16 - m_viewportH - 1; // Update viewport position m_viewportX = x; m_viewportY = y; // Set viewport SDL_Rect viewportRect = {-x, y - m_height / 2, m_width, m_height}; SDL_RenderSetViewport(m_renderer, &viewportRect); }
void CApp::OnRender() { // have a weak read only pointer for the purpose of // not needing .get() all the time. auto *renderer = _renderer.get(); SDL_RenderClear(renderer); SDL_RenderSetViewport(renderer, nullptr); for (auto *entity: CEntity::_entityList) { if (entity != nullptr) { entity->OnRender(renderer); } } SDL_RenderPresent(renderer); }
int main(int argc, char **argv) { if (!initSDL()) return 1; if (!loadMedia()) return 2; initViewportRect(); bool running = true; SDL_Event e; while (running) { while (SDL_PollEvent(&e)) { if (e.type == SDL_QUIT) running = false; } SDL_RenderClear(renderer); SDL_RenderSetViewport(renderer, &topLeftViewport); SDL_RenderCopy(renderer, texture, NULL, NULL); SDL_RenderSetViewport(renderer, &topRightViewport); SDL_RenderCopy(renderer, texture, NULL, NULL); SDL_RenderSetViewport(renderer, &bottomViewport); SDL_RenderCopy(renderer, texture, NULL, NULL); SDL_RenderPresent(renderer); } quitSDL(); return 0; }
bool SDLVideo::processOneFrame(Data data) { SDL_Event event; while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_WINDOWEVENT: if (event.window.event == SDL_WINDOWEVENT_RESIZED) { SDL_RenderSetViewport(renderer, nullptr); displayrect->w = event.window.data1; displayrect->h = event.window.data2; } break; case SDL_QUIT: #ifdef _MSC_VER GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0); #else std::raise(SIGTERM); #endif return false; } } auto pic = safe_cast<const DataPicture>(data); if (pic->getFormat() != pictureFormat) { pictureFormat = pic->getFormat(); createTexture(); } auto const now = m_clock->now(); auto const timestamp = pic->getTime() + PREROLL_DELAY; // assume timestamps start at zero auto const delay = std::max<int64_t>(0, timestamp - now); auto const delayInMs = clockToTimescale(delay, 1000); SDL_Delay((Uint32)delayInMs); if (pictureFormat.format == YUV420P) { SDL_UpdateYUVTexture(texture, nullptr, pic->getPlane(0), (int)pic->getPitch(0), pic->getPlane(1), (int)pic->getPitch(1), pic->getPlane(2), (int)pic->getPitch(2)); } else { SDL_UpdateTexture(texture, nullptr, pic->getPlane(0), (int)pic->getPitch(0)); } SDL_RenderCopy(renderer, texture, nullptr, displayrect.get()); SDL_RenderPresent(renderer); m_NumFrames++; return true; }
void DrawOnViewport(SDL_Renderer * renderer, SDL_Rect viewport) { SDL_Rect rect; /* Set the viewport */ SDL_RenderSetViewport(renderer, &viewport); /* Draw a gray background */ SDL_SetRenderDrawColor(renderer, 0x80, 0x80, 0x80, 0xFF); SDL_RenderClear(renderer); /* Test inside points */ SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xF, 0xFF); SDL_RenderDrawPoint(renderer, viewport.h/2 + 10, viewport.w/2); SDL_RenderDrawPoint(renderer, viewport.h/2 - 10, viewport.w/2); SDL_RenderDrawPoint(renderer, viewport.h/2 , viewport.w/2 - 10); SDL_RenderDrawPoint(renderer, viewport.h/2 , viewport.w/2 + 10); /* Test horizontal and vertical lines */ SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF); SDL_RenderDrawLine(renderer, 1, 0, viewport.w-2, 0); SDL_RenderDrawLine(renderer, 1, viewport.h-1, viewport.w-2, viewport.h-1); SDL_RenderDrawLine(renderer, 0, 1, 0, viewport.h-2); SDL_RenderDrawLine(renderer, viewport.w-1, 1, viewport.w-1, viewport.h-2); /* Test diagonal lines */ SDL_SetRenderDrawColor(renderer, 0x00, 0x00, 0xFF, 0xFF); SDL_RenderDrawLine(renderer, 0, 0, viewport.w-1, viewport.h-1); SDL_RenderDrawLine(renderer, viewport.w-1, 0, 0, viewport.h-1); /* Test outside points */ SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xF, 0xFF); SDL_RenderDrawPoint(renderer, viewport.h/2 + viewport.h, viewport.w/2); SDL_RenderDrawPoint(renderer, viewport.h/2 - viewport.h, viewport.w/2); SDL_RenderDrawPoint(renderer, viewport.h/2 , viewport.w/2 - viewport.w); SDL_RenderDrawPoint(renderer, viewport.h/2 , viewport.w/2 + viewport.w); /* Add a box at the top */ rect.w = 8; rect.h = 8; rect.x = (viewport.w - rect.w) / 2; rect.y = 0; SDL_RenderFillRect(renderer, &rect); }
static void sdl_refresh_renderer(sdl2_video_t *vid) { SDL_Rect r; SDL_RenderClear(vid->renderer); r.x = vid->vp.x; r.y = vid->vp.y; r.w = (int)vid->vp.width; r.h = (int)vid->vp.height; SDL_RenderSetViewport(vid->renderer, &r); /* breaks int scaling */ #if 0 SDL_RenderSetLogicalSize(vid->renderer, vid->vp.width, vid->vp.height); #endif }
SDL_Renderer * SDL_CreateSoftwareRenderer(SDL_Surface * surface) { #if !SDL_RENDER_DISABLED SDL_Renderer *renderer; renderer = SW_CreateRendererForSurface(surface); if (renderer) { renderer->magic = &renderer_magic; SDL_RenderSetViewport(renderer, NULL); } return renderer; #else SDL_SetError("SDL not built with rendering support"); return NULL; #endif /* !SDL_RENDER_DISABLED */ }
int SDL_RenderSetLogicalSize(SDL_Renderer * renderer, int w, int h) { CHECK_RENDERER_MAGIC(renderer, -1); if (!w || !h) { /* Clear any previous logical resolution */ renderer->logical_w = 0; renderer->logical_h = 0; SDL_RenderSetViewport(renderer, NULL); SDL_RenderSetScale(renderer, 1.0f, 1.0f); return 0; } renderer->logical_w = w; renderer->logical_h = h; return UpdateLogicalSize(renderer); }
void LTexture::render( int x, int y, const SDL_Rect* clip, double angle, SDL_Point* center, SDL_RendererFlip flip ){ SDL_Rect renderQuad = { x, y, mWidth * mScaling, mHeight * mScaling}; if( clip != NULL ){ renderQuad.w = clip->w * mScaling; renderQuad.h = clip->h * mScaling; } if(inGameViewport){ SDL_Rect topViewport; topViewport.x = 0; topViewport.y = 0; topViewport.w = SCREEN_WIDTH; topViewport.h = SCREEN_HEIGHT - MARGIN_BOTTOM; SDL_RenderSetViewport( gRenderer, &topViewport ); } //Render to screen SDL_RenderCopyEx( gRenderer, mTexture, clip, &renderQuad, angle, center, flip ); }
bool System_init(int width, int height) { if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) < 0) { log_error("SDL Init failed"); return false; } if (!SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1")) { log_error("SDL Set VSYNC failed"); } if (!(IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG)) { log_error("IMG Init failed"); return false; } if (TTF_Init() < 0) { log_error("TTF Init failed"); return false; } if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0) { log_error("Mix_OpenAudio failed"); return false; } window = System_createWindow(width, height); if (window == NULL) { return false; } renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED); SDL_Rect viewport = {0, 0, width, height}; SDL_RenderSetViewport(renderer, &viewport); ScoreBar_create(); Sound_load(); return true; }
static void process_events() { SDL_Event event; SDL_LockMutex(event_lock); while (SDL_PollEvent(&event)) { if (event.type == SDL_WINDOWEVENT) { if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) { SDL_GetWindowSize(screen,&win_w,&win_h); SDL_Rect newsize = boxify(); SDL_RenderSetViewport(renderer, &newsize); } } else if (event.type == SDL_QUIT) { end_emulation(); pending_sdl_thread_exit = true; #ifdef RUN_TESTS end_testing = true; #endif } } SDL_UnlockMutex(event_lock); }
void RenderManagerSDL::refresh() { SDL_SetRenderTarget(mRenderer, NULL); // We have a resizeable window // Resize renderer if needed // TODO: We should catch the resize event SDL_Rect renderRect; int windowX; int windowY; SDL_RenderGetViewport(mRenderer, &renderRect); SDL_GetWindowSize(mWindow, &windowX, &windowY); if (renderRect.w != windowX || renderRect.h != windowY) { renderRect.w = windowX; renderRect.h = windowY; SDL_RenderSetViewport(mRenderer, &renderRect); } SDL_RenderCopy(mRenderer, mRenderTarget, NULL, NULL); SDL_RenderPresent(mRenderer); SDL_SetRenderTarget(mRenderer, mRenderTarget); }
/* sdl events */ void processEvents(void) { SDL_Event event; while( SDL_WaitEvent( &event ) ) { switch( event.type ) { case SDL_KEYDOWN: keyPressed( &event.key.keysym ); break; case SDL_WINDOWEVENT: if(event.window.event == SDL_WINDOWEVENT_RESIZED){ if(!fullscreenFlag){ winWidth = event.window.data1; winHeight = event.window.data2; SDL_RenderSetViewport(screenRenderer, NULL); SDL_RenderClear(screenRenderer); if(streamObj) WV_resetStreamRendererOutput(streamObj, screenRenderer, NULL); // update the object } } break; case SDL_QUIT: closePlayer(); break; } /* there events are dynamics */ if(event.type == WV_REFRESH_EVENT) WV_refreshVideoFrame(&event); else if(event.type == WV_EOF_EVENT) closePlayer(); } }
int main(int argc, char **argv) { Uint8 *RawMooseData; SDL_RWops *handle; int window_w; int window_h; SDL_Window *window; SDL_Renderer *renderer; Uint8 MooseFrame[MOOSEFRAMES_COUNT][MOOSEFRAME_SIZE*2]; SDL_Texture *MooseTexture; SDL_Rect displayrect; SDL_Event event; int paused = 0; int i, j; int fps = 12; int fpsdelay; int nodelay = 0; Uint32 pixel_format = SDL_PIXELFORMAT_YV12; int scale = 5; SDL_bool done = SDL_FALSE; /* Enable standard application logging */ SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO); if (SDL_Init(SDL_INIT_VIDEO) < 0) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError()); return 3; } while (argc > 1) { if (strcmp(argv[1], "-fps") == 0) { if (argv[2]) { fps = atoi(argv[2]); if (fps == 0) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "The -fps option requires an argument [from 1 to 1000], default is 12.\n"); quit(10); } if ((fps < 0) || (fps > 1000)) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "The -fps option must be in range from 1 to 1000, default is 12.\n"); quit(10); } argv += 2; argc -= 2; } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "The -fps option requires an argument [from 1 to 1000], default is 12.\n"); quit(10); } } else if (strcmp(argv[1], "-nodelay") == 0) { nodelay = 1; argv += 1; argc -= 1; } else if (strcmp(argv[1], "-scale") == 0) { if (argv[2]) { scale = atoi(argv[2]); if (scale == 0) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "The -scale option requires an argument [from 1 to 50], default is 5.\n"); quit(10); } if ((scale < 0) || (scale > 50)) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "The -scale option must be in range from 1 to 50, default is 5.\n"); quit(10); } argv += 2; argc -= 2; } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "The -fps option requires an argument [from 1 to 1000], default is 12.\n"); quit(10); } } else if ((strcmp(argv[1], "-help") == 0) || (strcmp(argv[1], "-h") == 0)) { PrintUsage(argv[0]); quit(0); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Unrecognized option: %s.\n", argv[1]); quit(10); } break; } RawMooseData = (Uint8 *) malloc(MOOSEFRAME_SIZE * MOOSEFRAMES_COUNT); if (RawMooseData == NULL) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Can't allocate memory for movie !\n"); free(RawMooseData); quit(1); } /* load the trojan moose images */ handle = SDL_RWFromFile("moose.dat", "rb"); if (handle == NULL) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Can't find the file moose.dat !\n"); free(RawMooseData); quit(2); } SDL_RWread(handle, RawMooseData, MOOSEFRAME_SIZE, MOOSEFRAMES_COUNT); SDL_RWclose(handle); /* Create the window and renderer */ window_w = MOOSEPIC_W * scale; window_h = MOOSEPIC_H * scale; window = SDL_CreateWindow("Happy Moose", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, window_w, window_h, SDL_WINDOW_RESIZABLE); if (!window) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create window: %s\n", SDL_GetError()); free(RawMooseData); quit(4); } renderer = SDL_CreateRenderer(window, -1, 0); if (!renderer) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create renderer: %s\n", SDL_GetError()); free(RawMooseData); quit(4); } MooseTexture = SDL_CreateTexture(renderer, pixel_format, SDL_TEXTUREACCESS_STREAMING, MOOSEPIC_W, MOOSEPIC_H); if (!MooseTexture) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create texture: %s\n", SDL_GetError()); free(RawMooseData); quit(5); } /* Uncomment this to check vertex color with a YUV texture */ /* SDL_SetTextureColorMod(MooseTexture, 0xff, 0x80, 0x80); */ for (i = 0; i < MOOSEFRAMES_COUNT; i++) { Uint8 MooseFrameRGB[MOOSEFRAME_SIZE*3]; Uint8 *rgb; Uint8 *frame; rgb = MooseFrameRGB; frame = RawMooseData + i * MOOSEFRAME_SIZE; for (j = 0; j < MOOSEFRAME_SIZE; ++j) { rgb[0] = MooseColors[frame[j]].r; rgb[1] = MooseColors[frame[j]].g; rgb[2] = MooseColors[frame[j]].b; rgb += 3; } ConvertRGBtoYV12(MooseFrameRGB, MooseFrame[i], MOOSEPIC_W, MOOSEPIC_H, 0, 100); } free(RawMooseData); /* set the start frame */ i = 0; if (nodelay) { fpsdelay = 0; } else { fpsdelay = 1000 / fps; } displayrect.x = 0; displayrect.y = 0; displayrect.w = window_w; displayrect.h = window_h; /* Ignore key up events, they don't even get filtered */ SDL_EventState(SDL_KEYUP, SDL_IGNORE); /* Loop, waiting for QUIT or RESIZE */ while (!done) { while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_WINDOWEVENT: if (event.window.event == SDL_WINDOWEVENT_RESIZED) { SDL_RenderSetViewport(renderer, NULL); displayrect.w = window_w = event.window.data1; displayrect.h = window_h = event.window.data2; } break; case SDL_MOUSEBUTTONDOWN: displayrect.x = event.button.x - window_w / 2; displayrect.y = event.button.y - window_h / 2; break; case SDL_MOUSEMOTION: if (event.motion.state) { displayrect.x = event.motion.x - window_w / 2; displayrect.y = event.motion.y - window_h / 2; } break; case SDL_KEYDOWN: if (event.key.keysym.sym == SDLK_SPACE) { paused = !paused; break; } if (event.key.keysym.sym != SDLK_ESCAPE) { break; } case SDL_QUIT: done = SDL_TRUE; break; } } SDL_Delay(fpsdelay); if (!paused) { i = (i + 1) % MOOSEFRAMES_COUNT; SDL_UpdateTexture(MooseTexture, NULL, MooseFrame[i], MOOSEPIC_W*SDL_BYTESPERPIXEL(pixel_format)); } SDL_RenderClear(renderer); SDL_RenderCopy(renderer, MooseTexture, NULL, &displayrect); SDL_RenderPresent(renderer); } SDL_DestroyRenderer(renderer); quit(0); return 0; }
void Window::setViewPort( const lx::Graphics::ImgRect& viewport ) noexcept { const SDL_Rect VPORT = { viewport.p.x, viewport.p.y, viewport.w, viewport.h }; SDL_RenderSetViewport( m_wimpl->renderer, &VPORT ); }
void j1Render::ResetViewPort() { SDL_RenderSetViewport(renderer, &viewport); }
void j1Render::SetViewPort(const SDL_Rect& rect) { SDL_RenderSetViewport(renderer, &rect); }