C++ SDL_GetWindowSize函数代码示例

void display_canvas_text(Menu* main_menu) {
    int win_width, win_height;
    int canvas_text_x, canvas_text_y, canvas_text_w, canvas_text_h;
    SDL_Texture* image = load_image("display/images/program_a_work_of_art.bmp", 
                                      &main_menu->window);

    SDL_GetWindowSize(main_menu->window.win, &win_width, &win_height);

    canvas_text_x = main_menu->canvas_button.rect.w + win_width / LEFT_MARGIN;
    canvas_text_y = main_menu->canvas_button.rect.y;
    canvas_text_w = MENU_POPUP_WIDTH;
    canvas_text_h = MENU_POPUP_HEIGHT;

    make_rect(&main_menu->window, &main_menu->canvas_text, 
                canvas_text_x, canvas_text_y, canvas_text_w, canvas_text_h, 
                  230, 230, 230);

    SDL_RenderCopy(main_menu->window.renderer, image, 
                     NULL, &main_menu->canvas_text.rect);
    SDL_DestroyTexture(image); 
}

static inline void _gut_updatePhysic(SDL_Window *window) {
	int w, h;
	w = gut.core->window.physic.w;
	h = gut.core->window.physic.h;
	SDL_GetWindowSize(
		window,
		&gut.core->window.physic.w,
		&gut.core->window.physic.h
	);
	if (gut.reshape &&
		(w != gut.core->window.physic.w || h != gut.core->window.physic.h)) {
		gut.reshape(gut.core->window.physic.w, gut.core->window.physic.h);
	}
	if (!(gut.window.flags & GUT_NO_AUTO_VIEWPORT)) {
		glViewport(
			0, 0,
			gut.core->window.physic.w,
			gut.core->window.physic.h
		);
	}
}

void SDLAppDisplay::resize(int width, int height) {

    int resized_width, resized_height;

#if SDL_VERSION_ATLEAST(1,3,0)
    SDL_GetWindowSize(sdl_window, &resized_width, &resized_height);
#else
    setVideoMode(width, height, fullscreen);
    
    const SDL_VideoInfo* display_info = SDL_GetVideoInfo();

    resized_width  = display_info->current_w;
    resized_height = display_info->current_h;
#endif

    //set viewport to match what we ended up on
    glViewport(0, 0, resized_width, resized_height);

    this->width  = resized_width;
    this->height = resized_height;
}

int
SDL_RenderSetViewport(SDL_Renderer * renderer, const SDL_Rect * rect)
{
    CHECK_RENDERER_MAGIC(renderer, -1);

    if (rect) {
        renderer->viewport = *rect;
    } else {
        renderer->viewport.x = 0;
        renderer->viewport.y = 0;
        if (renderer->window) {
            SDL_GetWindowSize(renderer->window,
                              &renderer->viewport.w, &renderer->viewport.h);
        } else {
            /* This will be filled in by UpdateViewport() */
            renderer->viewport.w = 0;
            renderer->viewport.h = 0;
        }
    }
    return renderer->UpdateViewport(renderer);
}

void display_expert_text(Menu* challenges) {
    int win_width, win_height;
    int expert_text_x, expert_text_y, expert_text_w, expert_text_h;
    SDL_Texture* image = load_image("display/images/expert_text.bmp", 
                                      &challenges->window);

    SDL_GetWindowSize(challenges->window.win, &win_width, &win_height);

    expert_text_x = challenges->expert.rect.w + win_width / LEFT_MARGIN;
    expert_text_y = challenges->expert.rect.y;
    expert_text_w = MENU_POPUP_WIDTH;
    expert_text_h = MENU_POPUP_HEIGHT;

    make_rect(&challenges->window, &challenges->expert_text, 
                expert_text_x, expert_text_y, expert_text_w, expert_text_h, 
                  230, 230, 230);

    SDL_RenderCopy(challenges->window.renderer, image, 
                     NULL, &challenges->expert_text.rect);
    SDL_DestroyTexture(image); 
}

void setNavigationOffset(GraphicsData *graphicsData, int x, int y){
	int sx,sy;
	SDL_GetWindowSize(graphicsData->window,&sx,&sy);
	if(x + sx > X_SIZE_OF_WORLD){
		x = X_SIZE_OF_WORLD - sx;
	}
	else if(x < 0){
		x = 0;
	}
	if(y + sy > Y_SIZE_OF_WORLD){
		y = Y_SIZE_OF_WORLD - sy;
	}
	else if(y < 0){
		y = 0;
	}

	x = -x;
	y = -y;

	graphicsData->navigationOffset.x = x;
	graphicsData->navigationOffset.y = y;
}

	void CSprite::SetFullScreen(const bool bFull)
	{
		//Invert bool
		this->m_bFullScreen = bFull;

		//Fullscreen
		if (this->m_bFullScreen)
		{
			//Resize (First)
			SDL_GetWindowSize(this->m_pWin, &this->m_tScreenSize.w, &this->m_tScreenSize.h);
			SDL_SetWindowSize(this->m_pWin, SCREEN_WIDTH, SCREEN_HEIGHT);
			//Goto Windowed/FullScreen
			SDL_SetWindowFullscreen(this->m_pWin, this->m_bFullScreen);
		}
		else// Windowed
		{
			//Goto Windowed/FullScreen
			SDL_SetWindowFullscreen(this->m_pWin, this->m_bFullScreen);
			//Resize
			SDL_SetWindowSize(this->m_pWin, this->m_tScreenSize.w, this->m_tScreenSize.h);
		}
	}

void ImGui_ImplSDL2_NewFrame(SDL_Window* window)
{
    ImGuiIO& io = ImGui::GetIO();
    IM_ASSERT(io.Fonts->IsBuilt());     // Font atlas needs to be built, call renderer _NewFrame() function e.g. ImGui_ImplOpenGL3_NewFrame() 

    // Setup display size (every frame to accommodate for window resizing)
    int w, h;
    int display_w, display_h;
    SDL_GetWindowSize(window, &w, &h);
    SDL_GL_GetDrawableSize(window, &display_w, &display_h);
    io.DisplaySize = ImVec2((float)w, (float)h);
    io.DisplayFramebufferScale = ImVec2(w > 0 ? ((float)display_w / w) : 0, h > 0 ? ((float)display_h / h) : 0);

    // Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution)
    static Uint64 frequency = SDL_GetPerformanceFrequency();
    Uint64 current_time = SDL_GetPerformanceCounter();
    io.DeltaTime = g_Time > 0 ? (float)((double)(current_time - g_Time) / frequency) : (float)(1.0f / 60.0f);
    g_Time = current_time;

    ImGui_ImplSDL2_UpdateMousePosAndButtons();
    ImGui_ImplSDL2_UpdateMouseCursor();
}

    /// \brief Wrap the mouse to the viewport
    void InputWrapper::_wrapMousePointer(const SDL_MouseMotionEvent& evt)
    {
        //don't wrap if we don't want relative movements, support relative
        //movements natively, or aren't grabbing anyways
        if(!mMouseRelative || !mWrapPointer || !mGrabPointer)
            return;

        int width = 0;
        int height = 0;

        SDL_GetWindowSize(mSDLWindow, &width, &height);

        const int FUDGE_FACTOR_X = width/4;
        const int FUDGE_FACTOR_Y = height/4;

        //warp the mouse if it's about to go outside the window
        if(evt.x - FUDGE_FACTOR_X < 0  || evt.x + FUDGE_FACTOR_X > width
                || evt.y - FUDGE_FACTOR_Y < 0 || evt.y + FUDGE_FACTOR_Y > height)
        {
            warpMouse(width / 2, height / 2);
        }
    }

void SDLHardwareRenderDevice::windowResize() {
	int w,h;
	SDL_GetWindowSize(window, &w, &h);
	SCREEN_W = w;
	SCREEN_H = h;

	float scale = (float)VIEW_H / (float)SCREEN_H;
	VIEW_W = (int)((float)SCREEN_W * scale);

	// letterbox if too tall
	if (VIEW_W < MIN_SCREEN_W) {
		VIEW_W = MIN_SCREEN_W;
	}

	VIEW_W_HALF = VIEW_W/2;

	SDL_RenderSetLogicalSize(renderer, VIEW_W, VIEW_H);

	if (texture) SDL_DestroyTexture(texture);
	texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, VIEW_W, VIEW_H);
	SDL_SetRenderTarget(renderer, texture);
}

/**
 * Resize the screen filling the greatest area possible, but ignoring the
 *original aspect ratio. This shouldn't be used at all! Ò.Ó
 * @param	update_window	Whether the windows dimensions should be updated
 */
void GFraMe_screen_set_maximize_double(int update_window) {
	int w = 0, h = 0;
	// Get the actual window's dimension
	if (update_window) {
		SDL_GetWindowSize(GFraMe_window, &w, &h);
		GFraMe_window_w = w;
		GFraMe_window_h = h;
	}
	else {
		w = GFraMe_window_w;
		h = GFraMe_window_h;
	}
	// Letterbox the game
	GFraMe_buffer_x = 0;
	GFraMe_buffer_y = 0;
	GFraMe_buffer_w = w;
	GFraMe_buffer_h = h;
	GFraMe_screen_ratio_h = (double)w / GFraMe_screen_w;
	GFraMe_screen_ratio_v = (double)h / GFraMe_screen_h;
	GFraMe_screen_log_dimensions(0);
	GFraMe_screen_cache_dimensions();
}

int				sdl_env(int **map)
{
	t_env	*e;

	if (map == NULL)
		return (0);
	e = init_env(map);
	menu_loop(e);
	while (1)
	{
		while (SDL_PollEvent(&e->event))
		{
			SDL_GetWindowSize(e->win_sdl, &e->w, &e->h);
			handle_event(e);
			draw(e);
		}
	}
	if (ft_free(e))
		return (1);
	else
		return (0);
}

static int D3D_ActivateRenderer(SDL_Renderer * renderer)
{
	D3D_RenderData *data = (D3D_RenderData *) renderer->driverdata;
	HRESULT result;

	if (data->updateSize) {
		SDL_Window *window = renderer->window;
		int w, h;

		SDL_GetWindowSize(window, &w, &h);
		data->pparams.BackBufferWidth = w;
		data->pparams.BackBufferHeight = h;
		if (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) {
			data->pparams.BackBufferFormat =
				PixelFormatToD3DFMT(SDL_GetWindowPixelFormat(window));
		} else {
			data->pparams.BackBufferFormat = D3DFMT_UNKNOWN;
		}
		/* XXX if (D3D_Reset(renderer) < 0) {
		   return -1;
		   }*/

		data->updateSize = SDL_FALSE;
	}
	if (data->beginScene) {
		result = IDirect3DDevice9_BeginScene(data->device);
		if (result == D3DERR_DEVICELOST) {
			/* XXX if (D3D_Reset(renderer) < 0) {
			   return -1./include/GL/glext.h;
			   }*/
			result = IDirect3DDevice9_BeginScene(data->device);
		}
		if (FAILED(result)) {
			return SDL_SetError("SDL_Shader: D3D BeginScene() failed, errno %d\n", result);
		}
		data->beginScene = SDL_FALSE;
	}
	return 0;
}

void
MoveSprites(SDL_Window * window, SDL_Texture * sprite)
{
    int i, n;
    int window_w, window_h;
    int sprite_w, sprite_h;
    SDL_Rect *position, *velocity;

    SDL_SelectRenderer(window);

    /* Query the sizes */
    SDL_GetWindowSize(window, &window_w, &window_h);
    SDL_QueryTexture(sprite, NULL, NULL, &sprite_w, &sprite_h);

    /* Move the sprite, bounce at the wall, and draw */
    n = 0;
    SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF);
    SDL_RenderClear();
    for (i = 0; i < NUM_SPRITES; ++i) {
        position = &positions[i];
        velocity = &velocities[i];
        position->x += velocity->x;
        if ((position->x < 0) || (position->x >= (window_w - sprite_w))) {
            velocity->x = -velocity->x;
            position->x += velocity->x;
        }
        position->y += velocity->y;
        if ((position->y < 0) || (position->y >= (window_h - sprite_h))) {
            velocity->y = -velocity->y;
            position->y += velocity->y;
        }

        /* Blit the sprite onto the screen */
        SDL_RenderCopy(sprite, NULL, position);
    }

    /* Update the screen! */
    SDL_RenderPresent();
}

void SDLHardwareRenderDevice::windowResize() {
	int w,h;
	SDL_GetWindowSize(window, &w, &h);
	SCREEN_W = static_cast<unsigned short>(w);
	SCREEN_H = static_cast<unsigned short>(h);

	float scale = static_cast<float>(VIEW_H) / static_cast<float>(SCREEN_H);
	VIEW_W = static_cast<unsigned short>(static_cast<float>(SCREEN_W) * scale);

	// letterbox if too tall
	if (VIEW_W < MIN_SCREEN_W) {
		VIEW_W = MIN_SCREEN_W;
	}

	VIEW_W_HALF = VIEW_W/2;

	SDL_RenderSetLogicalSize(renderer, VIEW_W, VIEW_H);

	if (texture) SDL_DestroyTexture(texture);
	texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, VIEW_W, VIEW_H);
	SDL_SetRenderTarget(renderer, texture);
}