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