void Window::scaleRenderer()
{
if (this->_windowMode.w <= 0)
{
SDL_SetWindowSize(this->_window, 1, this->_windowMode.h);
}
if (this->_windowMode.h <= 0)
{
SDL_SetWindowSize(this->_window, this->_windowMode.w, 1);
}
SDL_RenderSetLogicalSize(this->_renderer,
this->_game->settings.getInt("RenderWidth"),
this->_game->settings.getInt("RenderHeight"));
// scale the renderer to the smallest window w/h, and to fill up the remaining empty space (assuming the aspect ratio wasn't conserved), increase the rendering resolution of that axis till it fits
// so the minimum scaled side retains its rendering resolution from settings.xml, but the other side increases its resolution to fit the window
int curWindW;
int curWindH;
SDL_GetWindowSize(this->_window, &curWindW, &curWindH);
int tempWinDMin = std::min(curWindW, curWindH);
int curRendW;
int curRendH;
SDL_RenderGetLogicalSize(this->_renderer, &curRendW, &curRendH);
int tempRendMin = std::min(curRendW, curRendH);
float aspectMin = static_cast<float>(tempWinDMin) / tempRendMin; // scale on both x and y
float tempWindMax = std::max(curWindW, curWindH);
//TODO: possible floating point inaccuracies
curRendW = (static_cast<int>(curRendW * aspectMin) == tempWinDMin) ? curRendW : tempWindMax / aspectMin;
curRendW = (static_cast<int>(curRendH * aspectMin) == tempWinDMin) ? curRendH : tempWindMax / aspectMin;
SDL_RenderSetLogicalSize(this->_renderer, curRendW, curRendH);
// set scale to be uniform on x and y
SDL_RenderSetScale(this->_renderer, aspectMin, aspectMin);
//it's scaled up and we want the min renderer side to remain the same, as it's currently already fitted nicely, but the other side? theres now a blank space, lets increase the rendering resolution of the renderer on that axis
SDL_RenderGetLogicalSize(this->_renderer, &this->_renderMode.w, &this->_renderMode.h);
SDL_RenderGetScale(this->_renderer, &this->_renderMode.scaleX, &this->_renderMode.scaleY);
}
void video_stretch(int enable)
{
stretch = enable;
if(window && !opengl)
{
if(stretch)
SDL_RenderSetLogicalSize(renderer, 0, 0);
else
SDL_RenderSetLogicalSize(renderer, stored_videomodes.hRes, stored_videomodes.vRes);
}
#ifdef GCW0 //testing
// SDL_RenderSetLogicalSize(renderer, 320, 240);
#endif
}
Tetris::Tetris() :
resourceLoader_( { DATA_INSTALL_DIR, DATA_SOURCE_DIR } )
{
try{
initSDL();
window_ = SDL_CreateWindow( "Moblok'",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
RES_X,
RES_Y,
0 );
if( !window_ ){
throw std::runtime_error( SDL_GetError() );
}
renderer_ = SDL_CreateRenderer( window_, -1, 0);
if( !renderer_ ){
throw std::runtime_error( SDL_GetError() );
}
SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "linear" );
SDL_RenderSetLogicalSize( renderer_, RES_X, RES_Y );
srand( time( NULL ) );
game_ = new GameLoop( window_, renderer_, &resourceLoader_ );
music_ = resourceLoader_.loadMusic( "Tetris_theme.ogg" );
}catch( const char* ){
throw;
}
}
bool Application::init(){
if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) != 0){
std::cout << "SDL_Init Error: " << SDL_GetError() << std::endl;
return false;
}
m_window = SDL_CreateWindow("Me versus It", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if (m_window == nullptr){
std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
return false;
}
m_renderer = SDL_CreateRenderer(m_window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (m_renderer == nullptr){
std::cout << "SDL_CreateRenderer Error: " << SDL_GetError() << std::endl;
return false;
}
if (TTF_Init() != 0){
std::cout << "TTF_Init Error: " << TTF_GetError() << std::endl;
return false;
}
SDL_RenderSetLogicalSize(m_renderer, SCREEN_WIDTH, SCREEN_HEIGHT);
SDL_SetRenderDrawColor(m_renderer, 0, 0, 0, 255);
srand((unsigned int)time(NULL));
for (std::vector<IGameObject*>::iterator it = m_gameobjects.begin(); it != m_gameobjects.end(); ++it){
(*it)->init();
}
m_curtime = SDL_GetTicks();
return true;
}
int Game::InitSDL() {
if( SDL_Init( SDL_INIT_EVERYTHING )<0 ) {
fprintf( stderr, "Unable to init SDL: %s\n", SDL_GetError() );
SDL_Quit();
return 1;
}
if( TTF_Init()<0 ) {
fprintf( stderr, "Unable to init SDL_TTF: %s\n", SDL_GetError() );
return 7;
}
window_ = SDL_CreateWindow(
"SDL Test Window",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
screenWidth_,
screenHeight_,
SDL_WINDOW_SHOWN );
if( window_==nullptr ) {
fprintf( stderr, "Create window failed: %s\n", SDL_GetError() );
SDL_Quit();
return 2;
}
renderer_ = SDL_CreateRenderer( window_, -1, SDL_RENDERER_ACCELERATED|SDL_RENDERER_PRESENTVSYNC );
if( renderer_==nullptr ) {
fprintf( stderr, "Create Renderer fails: %s\n", SDL_GetError() );
SDL_DestroyWindow( window_ );
SDL_Quit();
return 3;
}
SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "nearest" );
SDL_RenderSetLogicalSize( renderer_, screenWidth_, screenHeight_ );
loadAssets();
return 0;
}
void Application::Init(int argc, char* argv[]) {
//create and check the window
window = SDL_CreateWindow(
"Triple Triad",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
screenWidth,
screenHeight,
SDL_WINDOW_RESIZABLE);
if (!window) {
std::ostringstream msg;
msg << "Failed to create the window: " << SDL_GetError();
throw(std::runtime_error(msg.str()));
}
//create and check the renderer
renderer = SDL_CreateRenderer(window, -1, 0);
if (!renderer) {
std::ostringstream msg;
msg << "Failed to create the renderer: " << SDL_GetError();
throw(std::runtime_error(msg.str()));
}
//screen scaling
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "best");
SDL_RenderSetLogicalSize(renderer, 800, 600);
//set the hook for the renderer
BaseScene::SetRenderer(renderer);
}
int main(int argc, char* argv[])
{
if(SDL_Init(SDL_INIT_EVERYTHING) == -1) {
throw_SDLerror();
}
if(TTF_Init() == -1) {
throw_SDLerror();
}
window = SDL_CreateWindow(GAME_TITLE, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, GAME_WIDTH, GAME_HEIGHT, SDL_WINDOW_RESIZABLE);
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
SDL_RenderSetLogicalSize(renderer, GAME_WIDTH, GAME_HEIGHT);
// TODO: black loading screen is boring.
screen_clear();
screen_display();
asset_init();
Player_create();
Map_init();
run();
asset_quit();
TTF_Quit();
SDL_Quit();
return 0;
}
SDL_Renderer* InitSDLRenderer(SDL_Window* window)
{
//SDL_Renderer* renderer = SDL_CreateRenderer(window, -1,SDL_RENDERER_ACCELERATED);
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 0);
if(renderer != nullptr)
{
SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
#ifdef __ANDROID__
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "best");
#elif _WIN32
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "best");
#endif
//SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
SDL_RenderSetLogicalSize(renderer, 640, 360);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
}
if (renderer == nullptr)
{
logSDLError(std::cout, "InitSDLRenderer");
return nullptr;
}
return renderer;
}
Window::Window(const char *caption, u16 width, u16 height) {
m_width = width;
m_height = height;
m_window = SDL_CreateWindow(caption, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, m_width, m_height, SDL_WINDOW_SHOWN);
if(!m_window) {
fprintf(stderr, "Error while initializing window: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
m_renderer = SDL_CreateRenderer(m_window, -1, SDL_RENDERER_ACCELERATED);
if(!m_renderer) {
fprintf(stderr, "Renderer couldn't be created: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
m_viewportX = 0;
m_viewportY = 0;
#ifndef VIEWPORT
m_viewportW = m_width;
m_viewportH = m_height;
#else
m_viewportW = m_width / 2;
m_viewportH = m_height / 2;
SDL_RenderSetLogicalSize(m_renderer, m_viewportW, m_viewportH);
#endif
}
/**
* Toggle fullscreen using the internal GameEngine Variable
*/
void RenderHelper::ToggleFullScreen()
{
logger.Log("Toggle Fullscreen");
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
// make the scaled rendering look smoother.
SDL_RenderSetLogicalSize(m_cRenderer, m_iScreenWidth, m_iScreenHeight);
if( ! m_bFullscreen )
{
if( FullscreenOn() )
{
m_bFullscreen = true;
logger.LogError("Fullscreen successfully initialized");
}
else
{
logger.LogError("Turning Fullscreen On failed with error " + std::string(SDL_GetError()));
}
}
else
{
if( FullscreenOff() )
{
m_bFullscreen = false;
logger.LogError("Fullscreen successfully turned off");
}
else
{
logger.LogError("Turning Fullscreen off failed with error " + std::string(SDL_GetError()));
}
}
}
bool RenderHelper::FullscreenOn()
{
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
SDL_RenderSetLogicalSize(m_cRenderer, m_iScreenWidth, m_iScreenHeight);
SDL_SetWindowFullscreen(m_cWindow, SDL_WINDOW_FULLSCREEN_DESKTOP);
m_bFullscreen = true;
}
void SystemStub_SDL::init(const char *title, bool opengl, bool windowed, bool aspect, int windowW, int windowH) {
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK);
SDL_ShowCursor(SDL_DISABLE);
int flags = opengl ? SDL_WINDOW_OPENGL : 0;
if (windowed) {
flags |= SDL_WINDOW_RESIZABLE;
} else {
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
windowW = 0;
windowH = 0;
}
_window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, windowW, windowH, flags);
SDL_GetWindowSize(_window, &_w, &_h);
_renderer = SDL_CreateRenderer(_window, -1, SDL_RENDERER_ACCELERATED);
if (!windowed) {
setAspectRatio(_w, _h);
if (!opengl && aspect) {
SDL_RenderSetLogicalSize(_renderer, 320 * 3, 200 * 4);
}
} else {
_aspectRatio[0] = _aspectRatio[1] = 0.;
_aspectRatio[2] = _aspectRatio[3] = 1.;
}
_joystick = 0;
if (SDL_NumJoysticks() > 0) {
_joystick = SDL_JoystickOpen(0);
}
}
bool RenderHelper::FullscreenOff()
{
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
SDL_RenderSetLogicalSize(m_cRenderer, m_iScreenWidth, m_iScreenHeight);
SDL_SetWindowFullscreen(m_cWindow, SDL_FALSE);
m_bFullscreen = false;
}
void video_start_window( )
{
if ( SDL_VideoInit(video_options.driver) ) {
fatal( "%s", SDL_GetError() );
}
video_window = SDL_CreateWindow(
video_options.title,
video_options.position.x,
video_options.position.y,
video_options.size.w,
video_options.size.h,
SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI );
if ( video_window == NULL ) {
fatal( "%s", SDL_GetError() );
}
video_renderer = SDL_CreateRenderer( video_window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC );
if ( video_renderer == NULL ) {
fatal( "%s", SDL_GetError() );
}
SDL_SetRenderDrawBlendMode( video_renderer, SDL_BLENDMODE_BLEND );
SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" );
SDL_RenderSetLogicalSize(
video_renderer,
video_options.logical_size.w,
video_options.logical_size.h );
SDL_SetWindowGrab( video_window, video_options.grab_input );
if ( video_options.set_mode ) {
SDL_SetWindowDisplayMode( video_window, &video_options.mode );
} else {
SDL_SetWindowDisplayMode( video_window, NULL );
}
SDL_SetWindowFullscreen( video_window, video_options.fullscreen );
}
void video_set_logical_size( const struct size *size )
{
video_options.logical_size = *size;
if ( video_renderer != NULL ) {
SDL_RenderSetLogicalSize( video_renderer, size->w, size->h );
}
}
int
mncl_config_video(const char *title, int width, int height, int fullscreen, int flags)
{
if (!screen) {
screen = SDL_CreateWindow(title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height, fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
if (!screen) {
return 1;
}
renderer = SDL_CreateRenderer(screen, -1, 0);
if (!renderer) {
SDL_DestroyWindow(screen);
screen = NULL;
return 1;
}
mncl_begin_frame();
mncl_end_frame();
} else {
SDL_SetWindowFullscreen(screen, fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
if (!fullscreen) {
SDL_SetWindowSize (screen, width, height);
}
}
SDL_RenderSetLogicalSize(renderer, width, height);
is_fullscreen = fullscreen;
clear_color_r = clear_color_g = clear_color_b = 0;
win_width = width;
win_height = height;
SDL_ShowCursor((fullscreen && hide_mouse) ? SDL_DISABLE : SDL_ENABLE);
mncl_renormalize_all_spritesheets();
return 0;
}
void hw_enable_video(int enable)
{
if (enable && !g_videoenable)
{
screen = SDL_CreateWindow("Genemu - Sega Genesis Emulator",
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
WINDOW_WIDTH, WINDOW_WIDTH*3/4, SDL_WINDOW_RESIZABLE);
renderer = SDL_CreateRenderer(screen, -1, SDL_RENDERER_PRESENTVSYNC);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "nearest"); // make the scaled rendering look smoother.
SDL_RenderSetLogicalSize(renderer, 320, 240);
frame = SDL_CreateTexture(renderer,
SDL_PIXELFORMAT_ABGR8888,
SDL_TEXTUREACCESS_STREAMING,
320, 240);
}
else if (!enable && !g_videoenable)
{
SDL_DestroyTexture(frame); frame=NULL;
SDL_DestroyRenderer(renderer); renderer = NULL;
SDL_DestroyWindow(screen); screen = NULL;
}
g_videoenable = enable;
}
bool cWindow::InitWindow(const std::string& pWindowTitle) {
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK ) != 0) {
std::cout << "Failed to initialise SDL\n";
exit(1);
return false;
}
CalculateWindowSize();
mWindow = SDL_CreateWindow(pWindowTitle.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, GetWindowSize().mWidth, GetWindowSize().mHeight, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE );
if (!mWindow) {
std::cout << "Failed to create window\n";
exit(1);
return false;
}
mRenderer = SDL_CreateRenderer(mWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (!mRenderer) {
std::cout << "Failed to create rendered\n";
exit(1);
return false;
}
SDL_RenderSetLogicalSize(mRenderer, 366, 272);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, 0);
SetCursor();
return true;
}
void SDLWindow::Initialize()
{
assert(((start_location.w > 0 && start_location.h > 0) || start_location.w == start_location.h),
"If a special resolution modifier is to be used, then both length and width must be equal.");
if (start_location == USE_CURRENT_RESOLUTION)
{
SDL_DisplayMode display_mode;
assert((SDL_GetCurrentDisplayMode(DISPLAY_NUMBER, &display_mode) == 0), SDL_GetError());
start_location.w = (double)display_mode.w;
start_location.h = (double)display_mode.h;
}
if (fullscreen)
{
SDL_CreateWindowAndRenderer(0, 0,
(SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_BORDERLESS),
&window, &write_to);
// Scale so the user's code doesn't know the difference.
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear"); // make the scaled rendering look smoother.
SDL_RenderSetLogicalSize(write_to, GfxRound(start_location.w), GfxRound(start_location.h));
}
else
{
SDL_CreateWindowAndRenderer(GfxRound(start_location.w), GfxRound(start_location.h), 0, &window, &write_to);
}
SDL_SetWindowTitle(this->window, this->title);
SDL_SetRenderDrawColor(write_to, fill.r, fill.g, fill.b, fill.a);
SDL_RenderClear(write_to);
SDL_RenderPresent(write_to);
}
Game* createGame(char* title, int width, int height, float windowScale)
{
printf("Allocating %fMB of memory...\n", (float)sizeof(Game)/1024/1024);
Game* game = (Game*)calloc(1, sizeof(Game));
printf("Success!\n");
game->internalResolution = createPointi(width, height);
game->windowScale = windowScale;
State state;
state.level = 1;
state.stage = 1;
state.lives = 5;
state.score = 0;
game->state = state;
game->window = SDL_CreateWindow(
title,
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
(int)((float)width * windowScale), (int)((float)height * windowScale),
SDL_WINDOW_RESIZABLE | SDL_WINDOW_SHOWN);
//SDL_WINDOW_FULLSCREEN_DESKTOP);
game->renderer =
SDL_CreateRenderer(game->window, -1,
SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
SDL_RenderSetLogicalSize(game->renderer, width, height);
SDL_SetRenderDrawColor(game->renderer, 255, 255, 255, 255);
game->clearColor = createColor(0, 0, 0, 255);
game->drawAlpha = 1.0f;
return game;
}
void oledInit(void) {
if (SDL_Init(SDL_INIT_VIDEO) != 0) {
fprintf(stderr, "Failed to initialize SDL: %s\n", SDL_GetError());
exit(1);
}
atexit(SDL_Quit);
int scale = emulatorScale();
SDL_Window *window = SDL_CreateWindow("TREZOR",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
OLED_WIDTH * scale,
OLED_HEIGHT * scale,
0);
if (window == NULL) {
fprintf(stderr, "Failed to create window: %s\n", SDL_GetError());
exit(1);
}
renderer = SDL_CreateRenderer(window, -1, 0);
if (!renderer) {
fprintf(stderr, "Failed to create renderer: %s\n", SDL_GetError());
exit(1);
}
/* Use unscaled coordinate system */
SDL_RenderSetLogicalSize(renderer, OLED_WIDTH, OLED_HEIGHT);
texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, OLED_WIDTH, OLED_HEIGHT);
oledClear();
oledRefresh();
}
void vgainit(void)
{
if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
exit(1);
}
SDL_Surface *tmp = NULL;
tmp = SDL_CreateRGBSurfaceFrom(Icon, 64, 64, 8, 64, 0, 0, 0, 0);
SDL_SetColorKey(tmp, SDL_TRUE, 247);
SDL_SetPaletteColors(tmp->format->palette, IconPalette, 0, 256);
sdlWindow = SDL_CreateWindow("D I G G E R",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
0, 0,
SDL_WINDOW_OPENGL);
if(sdlWindow == NULL)
{
fprintf(stderr, "Couldn't initialize SDL window: %s\n", SDL_GetError());
exit(1);
}
SDL_SetWindowIcon(sdlWindow, tmp);
sdlRenderer = SDL_CreateRenderer(sdlWindow, -1, 0);
if(sdlRenderer == NULL)
{
fprintf(stderr, "Couldn't initialize SDL renderer: %s\n", SDL_GetError());
exit(1);
}
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear"); // make the scaled rendering look smoother.
SDL_RenderSetLogicalSize(sdlRenderer, 640, 480);
sdlTexture = SDL_CreateTexture(sdlRenderer,
SDL_PIXELFORMAT_ARGB8888,
SDL_TEXTUREACCESS_STREAMING,
640, 480);
if(sdlTexture == NULL)
{
fprintf(stderr, "Couldn't initialize SDL texture: %s\n", SDL_GetError());
exit(1);
}
screen = SDL_CreateRGBSurface(0, 640, 480, 8, 0, 0, 0, 0);
helper = SDL_CreateRGBSurface(0, 640, 480, 32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
if(screen == NULL || helper == NULL)
{
fprintf(stderr, "Couldn't initialize SDL surface: %s\n", SDL_GetError());
exit(1);
}
if(setmode() == false) {
fprintf(stderr, "Couldn't set 640x480x8 video mode: %s\n", SDL_GetError());
exit(1);
}
SDL_ShowCursor(0);
}
void Window::wasResized(int width, int height){
SDL_RenderSetLogicalSize(sdlRenderer, width, height);
windowRect.w = width;
windowRect.h = height;
if(currentMenu){
currentMenu->windowResized();
}
}
void SDLFrontend::updateViewport (int x, int y, int width, int height)
{
assert(_renderer);
SDL_RenderSetLogicalSize(_renderer, getWidth(), getHeight());
ShaderManager::get().updateProjectionMatrix(width, height);
}
void sdl2_2d_switch(DisplayChangeListener *dcl,
DisplaySurface *new_surface)
{
struct sdl2_console *scon = container_of(dcl, struct sdl2_console, dcl);
DisplaySurface *old_surface = scon->surface;
int format = 0;
assert(!scon->opengl);
scon->surface = new_surface;
if (scon->texture) {
SDL_DestroyTexture(scon->texture);
scon->texture = NULL;
}
if (!new_surface) {
sdl2_window_destroy(scon);
return;
}
if (!scon->real_window) {
sdl2_window_create(scon);
} else if (old_surface &&
((surface_width(old_surface) != surface_width(new_surface)) ||
(surface_height(old_surface) != surface_height(new_surface)))) {
sdl2_window_resize(scon);
}
SDL_RenderSetLogicalSize(scon->real_renderer,
surface_width(new_surface),
surface_height(new_surface));
switch (surface_format(scon->surface)) {
case PIXMAN_x1r5g5b5:
format = SDL_PIXELFORMAT_ARGB1555;
break;
case PIXMAN_r5g6b5:
format = SDL_PIXELFORMAT_RGB565;
break;
case PIXMAN_x8r8g8b8:
format = SDL_PIXELFORMAT_ARGB8888;
break;
case PIXMAN_r8g8b8x8:
format = SDL_PIXELFORMAT_RGBA8888;
break;
case PIXMAN_b8g8r8x8:
format = SDL_PIXELFORMAT_BGRX8888;
break;
default:
g_assert_not_reached();
}
scon->texture = SDL_CreateTexture(scon->real_renderer, format,
SDL_TEXTUREACCESS_STREAMING,
surface_width(new_surface),
surface_height(new_surface));
sdl2_2d_redraw(scon);
}
CAMLprim value
caml_SDL_RenderSetLogicalSize2(value renderer, value w, value h)
{
int r = SDL_RenderSetLogicalSize(
SDL_Renderer_val(renderer),
Int_val(w), Int_val(h));
if (r) caml_failwith("Sdlrender.set_logical_size2");
return Val_unit;
}
BRESULT scrnmng_create(int width, int height) {
SDL_Surface *surface;
SDL_PixelFormat *fmt;
BOOL r;
if (SDL_InitSubSystem(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0) {
fprintf(stderr, "Error: SDL_Init: %s\n", SDL_GetError());
return(FAILURE);
}
s_sdlWindow = SDL_CreateWindow(app_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height, 0);
s_renderer = SDL_CreateRenderer(s_sdlWindow, -1, 0);
SDL_RenderSetLogicalSize(s_renderer, width, height);
s_texture = SDL_CreateTexture(s_renderer, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STATIC, width, height);
s_surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 16, 0xf800, 0x07e0, 0x001f, 0);
surface = s_surface;
r = FALSE;
fmt = surface->format;
#if defined(SUPPORT_8BPP)
if (fmt->BitsPerPixel == 8) {
r = TRUE;
}
#endif
#if defined(SUPPORT_16BPP)
if ((fmt->BitsPerPixel == 16) && (fmt->Rmask == 0xf800) &&
(fmt->Gmask == 0x07e0) && (fmt->Bmask == 0x001f)) {
r = TRUE;
}
#endif
#if defined(SUPPORT_24BPP)
if (fmt->BitsPerPixel == 24) {
r = TRUE;
}
#endif
#if defined(SUPPORT_32BPP)
if (fmt->BitsPerPixel == 32) {
r = TRUE;
}
#endif
#if defined(SCREEN_BPP)
if (fmt->BitsPerPixel != SCREEN_BPP) {
r = FALSE;
}
#endif
if (r) {
scrnmng.enable = TRUE;
scrnmng.width = width;
scrnmng.height = height;
scrnmng.bpp = fmt->BitsPerPixel;
return(SUCCESS);
}
else {
fprintf(stderr, "Error: Bad screen mode");
return(FAILURE);
}
}
int main(int argc, char** argv) {
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
exit(1);
}
AVFormatContext *pFormatCtx;
if (avformat_open_input(&pFormatCtx, argv[1], NULL, NULL) != 0)
return -1;
if (avformat_find_stream_info(pFormatCtx, NULL) < 0)
return -1;
av_dump_format(pFormatCtx, 0, argv[1], 0);
AVCodecContext *pCodecCtx = NULL;
AVCodec *pCodec = NULL;
int videoStream = -1;
for (int i = 0; i < pFormatCtx->nb_streams; i++) {
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
videoStream = i;
break;
}
}
if (videoStream == -1)
exit(-1);
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
if (pCodec == NULL) {
fprintf(stderr, "%s\n", "Unsupported codecn");
exit(-1);
}
if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0)
exit(-1);
SDL_Window *surface;
surface = SDL_CreateWindow(argv[1],
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
pCodecCtx->width,
pCodecCtx->height,
SDL_WINDOW_FULLSCREEN | SDL_WINDOW_OPENGL);
if (!surface) {
fprintf(stderr, "%s\n", "SDL: could not set video mode - exiting");
exit(1);
}
SDL_Texture *texture = NULL;
SDL_Renderer *renderer = SDL_CreateRenderer(surface, -1, 0);
SDL_CreateWindowAndRenderer(0, 0, SDL_WINDOW_FULLSCREEN_DESKTOP, &surface, &renderer);
SDL_RenderSetLogicalSize(renderer, pCodecCtx->width, pCodecCtx->height);
texture = SDL_CreateTexture(renderer,
SDL_P)
struct SWSContext *sws_ctx = NULL;
}
int main(int argc, char * argv[])
{
//Load the config and apply
//Load the configs of screen
win_w = cfg.Load(KEY_WINWIDTH);
win_h = cfg.Load(KEY_WINHEIGHT);
//Load the volumn and apply
snd.ApplyCfg(BGMCN, cfg.Load(BGMCN));
snd.ApplyCfg(SECN, cfg.Load(SECN));
snd.ApplyCfg(VCECN, cfg.Load(VCECN));
//Init
SDL_Init(SDL_INIT_EVENTS);
win = SDL_CreateWindow("MaikazeSekai", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, win_w, win_h, SDL_WINDOW_OPENGL);
ren = SDL_CreateRenderer(win, -1, 0);
SDL_RenderSetLogicalSize(ren, 1280, 720);
blk = SDL_CreateTexture(ren, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, win_w, win_h);
//sent the renderer to Class Image as a stage and init them with the FileMgr
img.Init(ren, &file);
snd.Init(&file);
auto *rw = SDL_RWFromFile("z:/star.png", "r");
auto sur = IMG_Load_RW(rw, AUTOFREE);
auto tex = SDL_CreateTextureFromSurface(ren, sur);
SDL_FreeSurface(sur);
SDL_Rect rt = { 0, 0, 2362, 7087 };
SDL_RenderCopy(ren, tex, NULL, &rt);
SDL_RenderPresent(ren);
SDL_DestroyTexture(tex);
auto *rw2 = SDL_RWFromFile("z:/1.png", "r");
auto sur2 = IMG_Load_RW(rw2, AUTOFREE);
auto tex2 = SDL_CreateTextureFromSurface(ren, sur2);
SDL_FreeSurface(sur2);
SDL_Rect rt2 = { 0, 0, 800, 900 };
SDL_RenderCopy(ren, tex2, NULL, &rt2);
SDL_RenderPresent(ren);
//SDL_DestroyTexture(tex);
//
BGM("yui.wav", 1, 0);
BG("sample.png");
img.OnDraw();
//Refresh the textures on renderer
SDL_RenderPresent(ren);
UnLoadBG();
//SDL_DestroyTexture()
//Logo();
//Title();
SDL_Quit();
return 0;
}
renderer *renderer_new() {
renderer *new_renderer;
new_renderer = malloc(sizeof(renderer));
SDL_Init(SDL_INIT_VIDEO);
SDL_CreateWindowAndRenderer(0, 0, SDL_WINDOW_FULLSCREEN_DESKTOP, &new_renderer->sdl_window, &new_renderer->sdl_renderer);
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear"); // make the scaled rendering look smoother.
SDL_RenderSetLogicalSize(new_renderer->sdl_renderer, 640, 480);
return new_renderer;
}
