ModuleRender.cpp

#include "Globals.h"
#include "Application.h"
#include "ModuleRender.h"
#include "ModuleWindow.h"
#include "ModuleInput.h"
#include "SDL/include/SDL.h"

ModuleRender::ModuleRender() : Module()
{
	camera.x = camera.y = 0;
	camera.w = SCREEN_WIDTH;
	camera.h = SCREEN_HEIGHT;

	//fCameraSpeed = 0.5f; //define camera float speed
	currentCameraPosX = 0.0f;
}

// Destructor
ModuleRender::~ModuleRender()
{}

// Called before render is available
bool ModuleRender::Init()
{
	LOG("Creating Renderer context");
	bool ret = true;
	Uint32 flags = 0;

	if(REN_VSYNC == true)
	{
		flags |= SDL_RENDERER_PRESENTVSYNC;
	}

	renderer = SDL_CreateRenderer(App->window->window, -1, flags);

	SDL_RenderSetLogicalSize(renderer, SCREEN_WIDTH * SCREEN_SIZE, SCREEN_HEIGHT*SCREEN_SIZE); // Game size
	
	if(renderer == NULL)
	{
		LOG("Renderer could not be created! SDL_Error: %s\n", SDL_GetError());
		ret = false;
	}

	return ret;
}

// Called every draw update
update_status ModuleRender::PreUpdate()
{
	SDL_RenderClear(renderer);

	return update_status::UPDATE_CONTINUE;
}

update_status ModuleRender::Update()	
{
	/*int speed = 3;

	if(App->input->keyboard[SDL_SCANCODE_UP] == 1)
		camera.y += speed;

	if(App->input->keyboard[SDL_SCANCODE_DOWN] == 1)
		camera.y -= speed;

	if (App->input->keyboard[SDL_SCANCODE_LEFT] == 1)
		camera.x += speed;

	if (App->input->keyboard[SDL_SCANCODE_RIGHT] == 1)
		camera.x -= speed;*/

	return update_status::UPDATE_CONTINUE;
}

update_status ModuleRender::PostUpdate()
{
	SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE); // possibly problems with gameTitle and teamlogo
																 // fades
	SDL_RenderPresent(renderer);
	return update_status::UPDATE_CONTINUE;
}

// Called before quitting
bool ModuleRender::CleanUp()
{
	//if (!exitGameLoop)
	//{
		LOG("Destroying renderer");

		//Destroy window
		if (renderer != NULL)
		{
			SDL_DestroyRenderer(renderer);
		}
	//}
	//else
	//	exitGameLoop = false;

	return true;
}

// Blit to screen
bool ModuleRender::Blit(SDL_Texture* texture, int x, int y, SDL_Rect* section, float speedX, float speedY)
{

	Uint32 flags; //for store flipTexture parameters
	bool ret = true;
	SDL_Rect rect;
	SDL_Rect temporalSection;

	if(section != NULL)
		temporalSection = *section;
	
	rect.x = (int)(camera.x * speedX) + x * SCREEN_SIZE;
	rect.y = (int)(camera.y * speedY) + y * SCREEN_SIZE;


	if(section != NULL)
	{
		if (section->w < 0)
		{
			temporalSection.w = abs(section->w);
			flags |= SDL_FLIP_HORIZONTAL;
			
		}
		if (section->h < 0)
		{
			temporalSection.h = abs(section->h);
			flags |= SDL_FLIP_VERTICAL;
		}
		
		rect.w = abs(section->w);
		rect.h = abs(section->h);
		
	}
	else
	{
		SDL_QueryTexture(texture, NULL, NULL, &rect.w, &rect.h);
		temporalSection = rect;
	}

	rect.w *= SCREEN_SIZE;
	rect.h *= SCREEN_SIZE;
	

	if (SDL_RenderCopyEx(renderer, texture, &temporalSection , &rect, NULL, NULL, SDL_RendererFlip(flags)) != 0)
	{
  		LOG("Cannot blit to screen. SDL_RenderCopy error: %s", SDL_GetError());
		ret = false;
	}

	return ret;
}

bool ModuleRender::DrawQuad(const SDL_Rect& rect, Uint8 r, Uint8 g, Uint8 b, Uint8 a, bool use_camera)
{
	bool ret = true;

	SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
	SDL_SetRenderDrawColor(renderer, r, g, b, a);

	SDL_Rect rec(rect);
	if (use_camera)
	{
		rec.x = (int)(camera.x + rect.x * SCREEN_SIZE);
		rec.y = (int)(camera.y + rect.y * SCREEN_SIZE);
		rec.w *= SCREEN_SIZE;
		rec.h *= SCREEN_SIZE;
	}

	if (SDL_RenderFillRect(renderer, &rec) != 0)
	{
		LOG("Cannot draw quad to screen. SDL_RenderFillRect error: %s", SDL_GetError());
		ret = false;
	}

	return ret;
}