SDL Camera Logics

[Micard]

Hi guys! So here I have a little problem. I'm trying to create a simple camera in my SDL application. I have a big background (level) and a screen who is much smaller - basically the part that's going to move. I've seen some ways where people created classes etc for that, but I think it's too much for this kind of program. I mean it's not difficult to put it into class but I don't want to re-write what I already have, in addition it's almost working :)

So these are my dimensions for the level I have and the screen:

  #define LEVEL_WIDTH 1280      // Background's width
  #define LEVEL_HEIGHT 1920    // Background's height
  #define SCREEN_WIDTH 480    // Screen's (camera's) width
  #define SCREEN_HEIGHT 320   // Screen's (camera's) height 

So far everything is loading up and working fine, it's just that the camera is not being position over the bird (playable character) for some reason.

In the game loop I have this:

  Camera.x = (bird_rect.x + bird_rect.w / 2) - SCREEN_WIDTH / 2;
  Camera.y = (bird_rect.y + bird_rect.h / 2) - SCREEN_HEIGHT / 2;

Where bird_rect is what you control, a character if you wish. So here, supposedly, I make the camera to be actually over the bird, which for some reason is not true.

This is how I render the bird:

  SDL_RenderClear(renderer);

                  SDL_RenderCopy(renderer, textureBird, NULL, &bird_rect);

  SDL_RenderPresent(renderer);

My camera is a simple SDL_Rect, I'm not sure if I need to render it too but I tried this:

SDL_RenderDrawRect(renderer, &Camera);

Which didn't necessarily give me what I was looking for :)

Just in case the full code:

#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <iostream>

#define LEVEL_WIDTH 1280
#define LEVEL_HEIGHT 1920
#define SCREEN_WIDTH 480
#define SCREEN_HEIGHT 320

// Image/Texture loading function
SDL_Texture *load_texture(const char *fname, SDL_Renderer *renderer);

int main(int argc, char *argv[])
{
	// Initializing a window pointer / variable
	SDL_Window *window = nullptr;
	
	// Initializing window renderer / variable
	SDL_Renderer *renderer = nullptr;
	
	// Checking if video initialization was successful. If not - display error message and quit
	if(SDL_Init(SDL_INIT_VIDEO) != 0)
	{
		std::cout << " Generic Video Initialization Failed: " << SDL_GetError() << std::endl;
		SDL_Quit();
        std::exit(-1);
	}

		bool isRunning = true; // Variable for the main loop
		
		SDL_Event global; // Creating a "global" event to track button presses, mouse movements etc
		
		// Initializing the window itself (!!!SDL_WINDOW_FULLSCREEN!!! --NotToForget)
		window = SDL_CreateWindow("Attitude Indicator 1.00 Pre-A", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
		
		// Checking if window creation was successful. If not - display error message and quit
		if(window == nullptr)
		{
			std::cout << " Generic Window Creation Failed: " << SDL_GetError() << std::endl;
			SDL_Quit();
			std::exit(-1);
		}
		
		// Initializing the renderer itself (Window will not be created on RPi without a renderer --weird, dont forget to take a closer look)
		renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
		
		// Checking if renderer creation was successful. If not - display error message and quit
		if(renderer == nullptr)
		{
			std::cout << " Generic Renderer Creation Failed: " << SDL_GetError() << std::endl;
			SDL_Quit();
			std::exit(-1);
		}
		
		// Setting window color to WHITE
		SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
		
		// Initialize SDL_img
		int flags = IMG_INIT_JPG | IMG_INIT_PNG;
		int initted = IMG_Init(flags);		
		
		// Checking if the initialization of SDL_img was successful if not then say so and quit
		if((initted & flags) != flags)
		{
		 std::cout << " Generic Interface Loading Failed: " << IMG_GetError() << std::endl;
         IMG_Quit();
         SDL_Quit();
         std::exit(-1);
		}
		
/* -------------------------- Interface Properties Start -------------------------- */	
	
		// Load the Interface image in a texture
		SDL_Texture *textureInterface = nullptr;
		textureInterface = load_texture("AI_BGD_Rev2.png", renderer);
		// Interface Rectangle
		SDL_Rect interface_rect;
		// Interface's dimensions and position
		interface_rect.w = LEVEL_WIDTH;
		interface_rect.h = LEVEL_HEIGHT;
		interface_rect.x = (LEVEL_WIDTH / 2) - (interface_rect.w / 2);
		interface_rect.y = (LEVEL_HEIGHT / 2) - (interface_rect.h / 2);
		
/* -------------------------- Interface Properties End ---------------------------- */	
	
/* -------------------------- Bird Properties Start ------------------------------- */

		// Load the Bird image in a texture
		SDL_Texture *textureBird = nullptr;
		textureBird = load_texture("Bird2.png", renderer);
		// Bird Rectangle
		SDL_Rect bird_rect;
		// Bird's dimensions and position
		bird_rect.w = 214; 
		bird_rect.h = 35;
		bird_rect.x = (LEVEL_WIDTH / 2) - (bird_rect.w / 2); 
		bird_rect.y = (LEVEL_HEIGHT / 2) - (bird_rect.h / 2);

/* -------------------------- Bird Properties End --------------------------------- */		

/* -------------------------- Camera Properties Start ------------------------------- */

		// Initializing Main Camera
		SDL_Rect Camera;
		// Camera's dimensions and position
		Camera.x = 0;
		Camera.y = 0;
		Camera.w = SCREEN_WIDTH;
		Camera.h = SCREEN_HEIGHT;
/* -------------------------- Camera Properties End --------------------------------- */
		
		// Main Application Loop
			while(isRunning)
			{
				// Main Event Handler
				while(SDL_PollEvent(&global))
				{
					if(global.type == SDL_QUIT)
						isRunning = false;
					else if(global.type == SDL_KEYDOWN)
					{
						switch(global.key.keysym.sym)
						{
							case SDLK_ESCAPE:
								isRunning = false;
								break;
							case SDLK_w:
								bird_rect.y -= 2;
								break;
							case SDLK_s:
								bird_rect.y += 2;
								break;
							case SDLK_a:
								bird_rect.x -= 2;
								break;
							case SDLK_d:
								bird_rect.x += 2;
								break;
						}
					}
				}
				
				/*------------------------ Camera Controls Start ------------------------*/
				
				// Centering Camera over the bird
				Camera.x = (bird_rect.x + bird_rect.w / 2) - SCREEN_WIDTH / 2;
                Camera.y = (bird_rect.y + bird_rect.h / 2) - SCREEN_HEIGHT / 2;
				
				 //Keeping the Camera in bounds
                if( Camera.x < 0 )
                { 
                    Camera.x = 0;
                }
                if( Camera.y < 0 )
                {
                    Camera.y = 0;
                }
                if( Camera.x > LEVEL_WIDTH - Camera.w )
                {
                    Camera.x = LEVEL_WIDTH - Camera.w;
                }
                if( Camera.y > LEVEL_HEIGHT - Camera.h )
                {
                    Camera.y = LEVEL_HEIGHT - Camera.h;
                }
				
				/*------------------------ Camera Controls End --------------------------*/
				
				
				SDL_RenderClear(renderer); // Updating the renderer
				// Drawing the Interface and the Bird
				// {
					SDL_RenderCopy(renderer, textureInterface, NULL, &interface_rect);
					SDL_RenderCopy(renderer, textureBird, NULL, &bird_rect);
					SDL_RenderDrawRect(renderer, &Camera);
				// }
				SDL_RenderPresent(renderer); // Showing the renderer
			}
			
	
	
		// All the quit and destroy functions
		SDL_DestroyTexture(textureInterface);
		SDL_DestroyTexture(textureBird);
		IMG_Quit();
		SDL_DestroyRenderer(renderer);
		SDL_DestroyWindow(window);
		window = nullptr;
		renderer = nullptr;
		SDL_Quit();
	
	return 0;
}

// The image/texture loading function
 SDL_Texture *load_texture(const char *fname, SDL_Renderer *renderer) 
 {
    SDL_Surface *image = IMG_Load(fname);
	
	if(image == nullptr)
	{
		 std::cout << " Generic Interface Loading Failed: " << IMG_GetError() << std::endl;
         IMG_Quit();
         SDL_Quit();
         std::exit(-1);
	}
	 else
	 {
		 // Converting surface into texture
		SDL_Texture *img_texture = SDL_CreateTextureFromSurface(renderer, image);
		
		if(img_texture == nullptr)
		{
		 std::cout << " Generic Interface Loading Failed: " << IMG_GetError() << std::endl;
	     IMG_Quit();
         SDL_Quit();
         std::exit(-1);
		}
		
		SDL_FreeSurface(image); // Releasing the surface since we have a texture
		return img_texture;
	 }
 }

[poteto]

First of all, use classes, more functions, and don't use macros. This is not C.

Mainly do it for the repetitive parts and for readability, like you could just use a texture wrapper and sdl initialization function, but you should use a class to contain your textures and info because eventually you will want your program to be state orientated (the class should have a input & logic & render function).

But the source of your problems is the interface rect, when you initialize it, x and y are equal to zero:

interface_rect.w = LEVEL_WIDTH;
interface_rect.x = (LEVEL_WIDTH / 2) - (interface_rect.w / 2);

, so just make it equal to 0. Then after you set the camera, make interface_rect.x equal to camera.x, and same for y.