Exemple #1
0
bool Label::onDraw(SDL_Renderer *renderer) {
    //SDL_Texture *oldTarget;
    //oldTarget = SDL_GetRenderTarget(renderer);

    SDL_Texture *oldTarget = SDL_GetRenderTarget(renderer);
    SDL_SetRenderTarget(renderer, _texture);

    SDL_SetRenderDrawColor(renderer, bgColor.r, bgColor.g, bgColor.b, bgColor.a);
    SDL_RenderClear(renderer);
    SDL_Rect dst = {0, 0, 0, 0};

    SDL_QueryTexture(label, NULL, NULL, &dst.w, &dst.h);
    dst.x = (frame.w - dst.w) / 2;
    dst.y = (frame.h - dst.h) / 2;

    dst.w += padding.x + padding.w;
    dst.h += 8;
    LOGD("%dx%d%+d%+d\n", dst.x, dst.y, dst.w, dst.h);

    SDL_RenderCopy(renderer, label, NULL, &dst);
    SDL_SetRenderDrawColor(renderer, 0,0,0,255);

    dirty = false;
    SDL_SetRenderTarget(renderer, oldTarget);
}
void TransformableViewScene::Render(SDL_Renderer *renderer)
{
	SDL_Rect srcrect;
	srcrect.x = 0;
	srcrect.y = 0;
	srcrect.w = targetSize.x;
	srcrect.h = targetSize.y;
    
	SDL_Rect dstrect;
	dstrect.x = origin.x;
	dstrect.y = origin.y;
	dstrect.w = size.x;
	dstrect.h = size.y;
    
	auto target = SDL_GetRenderTarget(renderer);
    
	int res = SDL_SetRenderTarget(renderer, renderTarget.get());
    
    Uint8 r,g,b,a;
    SDL_GetRenderDrawColor(renderer, &r, &g, &b, &a);
    
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
    SDL_RenderClear(renderer);
    
    SDL_SetRenderDrawColor(renderer, r, g, b, a);
    
	scene->Render(renderer);
    
	res = SDL_SetRenderTarget(renderer, target);
	
	res = SDL_SetTextureAlphaMod(renderTarget.get(), opacity * 255);
    
	//SDL_RenderCopy(renderer, renderTarget.get(), &srcrect, &dstrect);
	SDL_RenderCopyEx(renderer, renderTarget.get(), &srcrect, &dstrect, rotation, &axis, SDL_FLIP_NONE);
}
Exemple #3
0
void FadeScene::Render(SDL_Renderer *renderer)
{
	SDL_Rect rect;
	rect.x = 0;
	rect.y = 0;
	rect.w = _w;
	rect.h = _h;

	auto target = SDL_GetRenderTarget(renderer);

	int res = SDL_SetRenderTarget(renderer, _renderTarget.get());
	_scene->Render(renderer);
	res = SDL_SetRenderTarget(renderer, target);
	
	if (_scene->Running() && _opacity != 255)
	{
		_opacity = std::min(_opacity + _speed, 255.0);
	}
	else if (!_scene->Running() && _opacity != 0)
	{
		_opacity = std::max(_opacity - _speed, 0.0);
	}

	res = SDL_SetTextureAlphaMod(_renderTarget.get(), _opacity);

	SDL_RenderCopy(renderer, _renderTarget.get(), &rect, &rect);
}
PackedTextures::PackedTextures(SDL_Renderer * ren, std::vector<SDL_Texture *> & texVec, std::vector<SDL_Rect> & srcRect) {
	int sum_height=0;
	int max_width = 0;
	SDL_Rect tRect;
	tRect.x = 0;
	for( int i=0; i<texVec.size(); i++) {
		tRect.w = srcRect[i].w;
		tRect.h = srcRect[i].h;

		if( max_width < tRect.w )
			max_width = tRect.w;
		tRect.y = sum_height;
		sum_height += tRect.h;
		placements.push_back(tRect);
	}

	packedTexture = SDL_CreateTexture(ren, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, max_width, sum_height);
	SDL_SetTextureBlendMode(packedTexture, SDL_BLENDMODE_NONE);

	SDL_Texture * pTarget = SDL_GetRenderTarget(ren);
	printf("Pack prev-renderer: %i\n",pTarget);
	printf("Pack new-texture: %i\n",packedTexture);
	SDL_SetRenderTarget(ren, packedTexture);
	SDL_SetRenderDrawColor(ren, 0, 0, 0, SDL_ALPHA_TRANSPARENT);
	SDL_RenderClear(ren);

	for( int i=0; i<texVec.size(); i++) {
		SDL_RenderCopy(ren, texVec[i], &srcRect[i], &placements[i]);
	}

	SDL_SetRenderTarget(ren, pTarget);
	SDL_SetTextureBlendMode(packedTexture, SDL_BLENDMODE_BLEND);
}
Exemple #5
0
void Range::generateTexture(SDL_Renderer * renderer)
{
    if(texture != nullptr)
    {
        SDL_DestroyTexture(texture);
        texture = nullptr;
    }

    setWidth(value * 2);
    setHeight(value * 2);

    SDL_Texture * prevRenderTarget = SDL_GetRenderTarget(renderer);
    texture = SDL_CreateTexture(renderer,SDL_PIXELFORMAT_UNKNOWN,SDL_TEXTUREACCESS_TARGET,getWidth(),getHeight());
    SDL_SetTextureBlendMode(texture,SDL_BLENDMODE_BLEND);

    SDL_SetRenderTarget(renderer,texture);
    SDL_SetRenderDrawColor(renderer,0,0,0,0);
    SDL_RenderClear(renderer);
    SDL_SetRenderDrawColor(renderer,255,0,0,255);



    for(double i = 0; i<=360; i+=0.01)
    {
        int x = value + value * cos(i);
        int y = value + value * sin(i);

        SDL_RenderDrawPoint(renderer,x,y);
    }




    SDL_SetRenderTarget(renderer,prevRenderTarget);
}
void PlayerStatHUD::draw(SDL_Renderer * renderer)
{
	if(texture == NULL)
	{
		texture = SDL_CreateTexture(renderer,SDL_PIXELFORMAT_UNKNOWN,SDL_TEXTUREACCESS_TARGET,
			area.w,area.h);
	}

	SDL_Texture * callerTarget = SDL_GetRenderTarget(renderer);
	SDL_SetRenderTarget(renderer,texture);
	SDL_SetRenderDrawColor(renderer,0,0,0,0);
	SDL_RenderClear(renderer);
	lifeSprite.draw(renderer);
	goldSprite.draw(renderer);
	

	SDL_SetRenderTarget(renderer,callerTarget);
	SDL_RenderCopy(renderer,texture,NULL,&area);

}
Exemple #7
0
bool View::draw(SDL_Renderer* renderer) {
    int w;
    //SDL_QueryTexture(texture, NULL, NULL, &w, NULL);
    SDL_Texture *oldTarget = SDL_GetRenderTarget(renderer);
    SDL_SetRenderTarget(renderer, getTexture());
    SDL_RenderClear(renderer);
    for(std::vector<Widget*>::iterator it = children.begin(); it != children.end(); it++) {
        Widget *w = *it;
        if (w->isDirty()) {// continue;
            w->draw(renderer);
        }
        SDL_Rect extents;
        w->getExtents(&extents);
        extents.x += padding.x;
        extents.y += padding.y;
        SDL_RenderCopy(renderer, w->getTexture(), NULL, &extents);
    }
    dirty = false;
    SDL_SetRenderTarget(renderer, oldTarget);
    return dirty;
}
Exemple #8
0
void Container::draw(SDL_Renderer * renderer)
{
	if(isVisible())
	{
		if(renderTarget == nullptr)
		{
			renderTarget = SDL_CreateTexture(renderer,SDL_PIXELFORMAT_UNKNOWN,SDL_TEXTUREACCESS_TARGET,getWidth(),getHeight());
			SDL_SetTextureBlendMode(renderTarget,SDL_BLENDMODE_BLEND);
		}


		SDL_Texture * callerTexture = SDL_GetRenderTarget(renderer);

		SDL_SetRenderTarget(renderer,renderTarget);

		SDL_SetRenderDrawColor(renderer,bgColor.r,bgColor.g,bgColor.b,bgColor.a);

		SDL_RenderClear(renderer);

	
		for(it = widgets.begin();it != widgets.end();++it)
		{
			(*it)->draw(renderer);
		}

		SDL_SetRenderTarget(renderer,callerTexture);

		SDL_RenderCopy(renderer,renderTarget,NULL,&getArea());

		if(borderVisible)
		{
			SDL_Color bc = getBorderColor();
			SDL_SetRenderDrawColor(renderer,bc.r,bc.g,bc.b,bc.a);
			SDL_RenderDrawRect(renderer,&area);
		}

		callerTexture = NULL;
	}
}
void SdlBaseContainerView::Render()
{
	if (!model.IsVisible() || model.IsEmpty()) return;

	SDL_Renderer *renderer = display.GetRenderer();

	//TODO: Currently, we assume that the render target is the whole screen.
	SDL_Texture *oldRenderTarget = nullptr;
	if (rttTarget) {
		oldRenderTarget = SDL_GetRenderTarget(renderer);
		SDL_SetRenderTarget(renderer, rttTarget->Get());
		SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
		SDL_RenderClear(renderer);
	}

	bool clip = model.IsClip();
	SDL_Rect oldClip = { 0, 0, 0, 0 };

	if (clip) {
		// Translate our bounds into screen-space.
		Vec2 pos = display.LayoutUiPosition(
			model.GetAlignedPos(model.GetSize().x, model.GetSize().y));

		const Vec2 &size = model.GetSize();
		double w = size.x;
		double h = size.y;
		if (!model.IsLayoutUnscaled()) {
			double uiScale = display.GetUiScale();
			w *= uiScale;
			h *= uiScale;
		}

		screenPos = pos;
		screenSize.x = w;
		screenSize.y = h;

		SDL_RenderGetClipRect(renderer, &oldClip);
		SDL_Rect ourClip = {
			static_cast<int>(pos.x), static_cast<int>(pos.y),
			static_cast<int>(w), static_cast<int>(h) };
		SDL_Rect clipRect = { 0, 0, 0, 0 };

		// If there's an existing clip area, then set the clip rect to be
		// the intersection of the two areas.
		if (oldClip.w == 0 || oldClip.h == 0) {
			clipRect = ourClip;
		}
		else {
			if (!SDL_IntersectRect(&oldClip, &ourClip, &clipRect)) {
				// If there's no intersection, set a tiny off-screen rect so
				// the existing clip area check still works.
				clipRect.x = -1;
				clipRect.y = -1;
				clipRect.w = 1;
				clipRect.h = 1;
			}
		}

		SDL_RenderSetClipRect(renderer, &clipRect);
	}

	const Vec2 &size = model.GetSize();
	Vec2 origin = model.GetAlignedPos(size.x, size.y);
	origin += model.GetChildOffset();

	Vec2 oldOrigin = display.AddUiOrigin(origin);
	auto oldFlags = display.AddUiLayoutFlags(model.GetLayoutFlags());
	model.ForEachVisibleChild(std::mem_fn(&ViewModel::Render));
	display.SetUiLayoutFlags(oldFlags);
	display.SetUiOrigin(oldOrigin);

	if (clip) {
		SDL_RenderSetClipRect(renderer, &oldClip);
	}

	if (rttTarget) {
		SDL_SetRenderTarget(renderer, oldRenderTarget);

		// Draw the render target with the selected opacity.
		SDL_Texture *tex = rttTarget->Get();
		SDL_SetTextureBlendMode(tex, SDL_BLENDMODE_BLEND);
		SDL_SetTextureAlphaMod(tex,
			static_cast<MR_UInt8>(255.0 * model.GetOpacity()));
		SDL_SetTextureColorMod(tex, 0xff, 0xff, 0xff);

		SDL_RenderCopy(renderer, tex, nullptr, nullptr);
	}
}
Exemple #10
0
bool Button::draw(SDL_Renderer* renderer) {

    /*if(label->isDirty()) {
        label->draw();
    }*/
    SDL_Texture *oldTarget = SDL_GetRenderTarget(renderer);
    SDL_SetRenderTarget(renderer, _texture);
    SDL_SetRenderDrawColor(renderer, 0,0,0,0);
    SDL_RenderClear(renderer);
    SDL_SetRenderDrawColor(renderer, 0,0,0,255);
    SDL_Rect extents = {0, 0, frame.w, frame.h};
    _theme->draw(renderer, &extents);
    SDL_Rect contentRect;
    getContentRect(&contentRect);
    //printf("Content rect: %dx%d%+d%+d\n", contentRect.w, contentRect.h, contentRect.x, contentRect.y);
    //contentRect.x = padding.x;
    //contentRect.y = padding.y;
    //contentRect.w += padding.x + padding.w;
    //contentRect.h += padding.y + padding.h;
    //-- SDL_RenderCopy(renderer, label->getTexture(), NULL, &contentRect);
    /*printf("contentRect.w: %d\n", contentRect.w);
    int w;
    SDL_QueryTexture(label->getTexture(), NULL, NULL, &w, NULL);
    printf("label with: %d\n", w);*/
#if 0
    SDL_Point srcPoints[] = {
        {0, 0},
        {padding.x, padding.y},
        {w - padding.w, h - padding.h},
        {w, h}
    };
    SDL_Point dstPoints[] = {
        {frame->x, frame->y},
        {frame->x + padding.x, frame->y + padding.y},
        {frame->x + frame->w - padding.w, frame->y + frame->h - padding.h},
        {frame->x + frame->w, frame->y + frame->h}
    };
    for (int y = 0; y < 3; y++ ) {
        for (int x = 0; x < 3; x++) {
            SDL_Rect src = {
                srcPoints[x].x,
                srcPoints[y].y,
                srcPoints[x+1].x,
                srcPoints[y+1].y
            };
            src.w -= src.x;
            src.h -= src.y;

            SDL_Rect dst = {
                dstPoints[x].x,
                dstPoints[y].y,
                dstPoints[x+1].x,
                dstPoints[y+1].y
            };
            dst.w -= dst.x;
            dst.h -= dst.y;
            //printf("%d,%d\n", x, y);
            //printf("src: %dx%d%+d%+d\n", src.w, src.h, src.x, src.y);
            //printf("dst: %dx%d%+d%+d\n\n", dst.w, dst.h, dst.x, dst.y);
            /*printf("src: %d+%d+%dx%d dst: %d+%d+%dx%d\n",
                src.x, src.y, src.w, src.h,
                dst.x, dst.y, dst.w, dst.h);*/
            SDL_RenderCopy(texture, &src, &dst);
            //SDL_SetRenderDrawColor(renderer, 32+x*32, 32+y*32, 0, 127);
            //SDL_RenderFillRect(renderer, &dst);
        }
    }
#endif
    dirty = false;
    SDL_SetRenderTarget(renderer, oldTarget);
    return true;
}
Exemple #11
0
SDL_Texture * Renderer::getTarget() const
{
	return SDL_GetRenderTarget(m_renderer);
}
Exemple #12
0
static bool handle_event_in_level(Game *game, SDL_Event *event)
{
    if (event->type == SDL_USEREVENT) {
        switch (event->user.code) {
        case SECOND_ELAPSED_EVENT:
            game->time_left--;

            if (game->time_left == 0) {
                puts("Time's up!");

                SDL_Color blue = { 0, 0xDB, 0xEB, 0xFF };
                SDL_Texture *missed_words = render_empty_words(game, blue);
                SDL_Texture *original_render_target =
                    SDL_GetRenderTarget(game->renderer);
                SDL_SetRenderTarget(game->renderer, game->guessed_words_texture);
                SDL_RenderCopy(game->renderer, missed_words, NULL, NULL);
                SDL_SetRenderTarget(game->renderer, original_render_target);

                // TODO: This could be made more efficient by keeping an index
                // into guessed_words too.
                for (size_t i = 0; i < game->anagrams->count; i++) {
                    char *word = GET_WORD(game->anagrams, i);
                    if (word_position(game->guessed_words, word) == -1)
                        render_guessed_word(game, word);
                }

                bool guessed_a_six_letter_word = false;
                for (size_t i = 0; i < game->guessed_words->count; i++) {
                    if (strlen(GET_WORD(game->guessed_words, i)) == 6) {
                        guessed_a_six_letter_word = true;
                        break;
                    }
                }

                if (guessed_a_six_letter_word) {
                    char *message = "You qualify for the next round!";
                    puts(message);
                    game->state = WON_LEVEL;
                    game->message_box = render_message_box(game, message);

                    return true;
                } else {
                    printf("You suck, you failed. No new level for you\n"
                           "Your final score was %d\n", game->points);
                    game->state = GAME_OVER;
                    game->message_box = render_message_box(game, "Game over, loser");
                    return true;
                }
            }

            break;
        }

        return true;
    } else if (event->type != SDL_KEYDOWN) {
        return true;
    }

    SDL_KeyboardEvent kbe = event->key;
    SDL_Keycode vk = kbe.keysym.sym;
    if (vk == SDLK_ESCAPE) {
        return false;
    } else if ((vk >= 'a') && (vk <= 'z')) {
        int removed_char_index = -1;
        for (size_t i = 0; i < MAX_WORD_LENGTH - game->chars_entered; i++) {
            char c = game->remaining_chars[i];

            if (c == vk) {
                removed_char_index = i;
                break;
            }
        }

        if (removed_char_index == -1)
            return true;
        for (int i = removed_char_index; i < MAX_WORD_LENGTH; i++)
            game->remaining_chars[i] = game->remaining_chars[i + 1];

        game->curr_input[game->chars_entered++] = vk;

    } else if (vk == SDLK_BACKSPACE) {
        if (game->chars_entered != 0) {
            game->chars_entered--;
            char removed = game->curr_input[game->chars_entered];
            game->remaining_chars[
                MAX_WORD_LENGTH - game->chars_entered - 1] = removed;
            game->curr_input[game->chars_entered] = '\0';
        }
    } else if (vk == SDLK_SPACE) {
        shuffle(game->remaining_chars);
    } else if (vk == SDLK_RETURN) {
        size_t length = strlen(game->curr_input);
        int position;
        if (length < 3 || length > 6) {
            printf("%s is not the right length\n", game->curr_input);
        } else if (word_position(game->guessed_words, game->curr_input) != -1) {
            printf("you've already guessed %s\n", game->curr_input);
        } else if ((position = word_position(
                                   game->anagrams_by_length[length - 3],
                                   game->curr_input))
                   != -1) {
            printf("yep, %s is correct\n", game->curr_input);

            memcpy(GET_WORD(game->guessed_words, game->guessed_words->count),
                   game->curr_input, length);
            game->guessed_words->count++;

            render_guessed_word(game, game->curr_input);

            game->points += 10 * length * length;

            if (game->guessed_words->count == game->anagrams->count) {
                char *message = "You guessed all the words!";

                puts(message);
                game->message_box = render_message_box(game, message);
                game->state = WON_LEVEL;

                // Bonus for guessing all the words.
                game->points += game->anagrams->count * 200 + 100;

                return true;
            }
        } else {
            printf("no, %s is wrong\n", game->curr_input);
        }

        memcpy((game->remaining_chars + MAX_WORD_LENGTH) - game->chars_entered,
               game->curr_input, game->chars_entered);
        memset(game->curr_input, 0, game->chars_entered);
        game->chars_entered = 0;
    }

    return true;
}
void ScrollableContainer::draw(SDL_Renderer * renderer)
{
	if(isVisible())
	{
		if(renderTarget == NULL)
		{
			renderTarget = SDL_CreateTexture(renderer,SDL_PIXELFORMAT_UNKNOWN,SDL_TEXTUREACCESS_TARGET,getWidth(),getHeight());
		}

		if(childAreaTexture == nullptr)
		{
			childAreaTexture = SDL_CreateTexture(renderer,SDL_PIXELFORMAT_UNKNOWN,SDL_TEXTUREACCESS_TARGET,childArea.w,childArea.h);
		}

		SDL_Texture * callerTexture = SDL_GetRenderTarget(renderer);

		SDL_SetRenderTarget(renderer,renderTarget);

		SDL_SetRenderDrawColor(renderer,bgColor.r,bgColor.g,bgColor.b,bgColor.a);

		SDL_RenderClear(renderer);


		SDL_SetRenderTarget(renderer,childAreaTexture);
		SDL_RenderClear(renderer);


		for(it = widgets.begin();it != widgets.end();++it)
		{
			(*it)->draw(renderer);
		}

		SDL_Color prevColor;

		SDL_SetRenderTarget(renderer,renderTarget);
		SDL_RenderCopy(renderer,childAreaTexture,nullptr,&childArea);

		if(vScroll || hScroll)
		{
			SDL_GetRenderDrawColor(renderer,&prevColor.r,&prevColor.g,&prevColor.b,&prevColor.a);

			SDL_SetRenderDrawColor(renderer,scrollColor.r,scrollColor.g,scrollColor.b,scrollColor.a);
			if(vScroll)
			{
				SDL_RenderFillRect(renderer,&vScrollRect);
			}

			if(hScroll)
			{
				SDL_RenderFillRect(renderer,&hScrollRect);
			}

			SDL_SetRenderDrawColor(renderer,prevColor.r,prevColor.g,prevColor.b,prevColor.a);
		}

		if(borderVisible)
		{
			SDL_GetRenderDrawColor(renderer,&prevColor.r,&prevColor.g,&prevColor.b,&prevColor.a);

			SDL_SetRenderDrawColor(renderer,0,0,255,255);

			SDL_RenderDrawRect(renderer,&childArea);

			SDL_SetRenderDrawColor(renderer,prevColor.r,prevColor.g,prevColor.b,prevColor.a);
		}
		

		SDL_SetRenderTarget(renderer,callerTexture);

		SDL_RenderCopy(renderer,renderTarget,NULL,&getArea());
		callerTexture = NULL;
	}
}
Exemple #14
0
void hc_map::draw(SDL_Rect *viewport, vector<hc_npc*> npcs, hc_npc *player)
{
	//hc_debug << "tiles: " << background.size() << " from: " << info.height * info.width << endl;
	if(background.size() != info.height * info.width || info.height * info.width == 0)
	{
		return;
	}

	if(!background_texture)
	{
		background_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, info.width * 16, info.height * 16);
		if(!background_texture)
		{
			hc_fatal << "Unable to create Texture: " << SDL_GetError() << endl;
			exit(0);
		}
		SDL_SetTextureBlendMode(background_texture, SDL_BLENDMODE_NONE);
	}

	if(!objects_texture)
	{
		objects_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, info.width * 16, info.height * 16);
		if(!objects_texture)
		{
			hc_fatal << "Unable to create Texture: " << SDL_GetError() << endl;
			exit(0);
		}
		SDL_SetTextureBlendMode(objects_texture, SDL_BLENDMODE_BLEND);
	}

	if(!npc_texture)
	{
		npc_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, info.width * 16, info.height * 16);
		if(!npc_texture)
		{
			hc_fatal << "Unable to create Texture: " << SDL_GetError() << endl;
			exit(0);
		}
		SDL_SetTextureBlendMode(npc_texture, SDL_BLENDMODE_BLEND);
	}


	//hc_debug << "Draw map: " << info.name << endl;
	if(background_changed)
	{
		hc_debug << "Rerender background" << endl;
		SDL_Texture *old_texture;
		old_texture = SDL_GetRenderTarget(renderer);
		SDL_SetRenderTarget(renderer, background_texture);
		SDL_SetRenderDrawColor(renderer, 255, 0, 255, 255);
		SDL_RenderClear(renderer);

		for(auto tile:background)
		{
			bool around[3][3];
			uint32_t here_x, here_y;
			tile.get_coordinates(&here_x, &here_y);

			for(int32_t y = -1; y < 2; y++)
			{
				for(int32_t x = -1; x < 2; x++)
				{
					if(here_x + x == -1 || here_x + x == info.width || here_y + y == -1 || here_y + y == info.height)
					{
						around[x + 1][y + 1] = true;
					}
					for(auto tile_around:background) // TODO: bad solution, very slow
					{
						uint32_t there_x, there_y;
						tile_around.get_coordinates(&there_x, &there_y);
						if(there_x == here_x + x && there_y == here_y + y)
						{
							if(tile.get_tileset() == tile_around.get_tileset())
							{
								around[x + 1][y + 1] = true;
							}
							else
							{
								around[x + 1][y + 1] = false;
							}

							break;
						}
					}

				}
			}
			tile.draw_as_background(tileset, around);
		}


		background_changed = false;
		SDL_SetRenderTarget(renderer, old_texture);
	}

	if(objects_changed)
	{
		hc_debug << "Rerender objects" << endl;
		SDL_Texture *old_texture;
		old_texture = SDL_GetRenderTarget(renderer);
		SDL_SetRenderTarget(renderer, objects_texture);
		SDL_SetRenderDrawColor(renderer, 255, 0, 255, 0);
		SDL_RenderClear(renderer);

		for(auto tile:objects)
		{
			tile.draw_as_sprite(tileset);
		}
		objects_changed = false;
		SDL_SetRenderTarget(renderer, old_texture);
	}

	{
		SDL_Texture *old_texture;
		old_texture = SDL_GetRenderTarget(renderer);
		SDL_SetRenderTarget(renderer, npc_texture);
		SDL_SetRenderDrawColor(renderer, 255, 0, 255, 0);
		SDL_RenderClear(renderer);
		for(auto npc:npcs)
		{
			npc->draw();
		}
		SDL_SetRenderTarget(renderer, old_texture);
	}

	SDL_Rect source;
	SDL_Rect target;

	int32_t player_x = 0;
	int32_t player_y = 0;

	player->get_pos(&player_x, &player_y);

	player_x += 8; //Half the NPC-sprite-size
	player_y += 8;

	uint32_t map_w = info.width * 16;
	uint32_t map_h = info.height * 16;

	if(map_w <= viewport->w)
	{
		source.w = map_w;
		target.w = map_w;

		source.x = 0;
		target.x = viewport->x + viewport->w / 2 - map_w / 2;
	}
	else
	{
		source.w = viewport->w;
		target.w = viewport->w;

		source.x = player_x - viewport->w / 2;
		target.x = viewport->x;
	}

	if(map_h <= viewport->h)
	{
		source.h = map_h;
		target.h = map_h;

		source.y = 0;
		target.y = viewport->y + viewport->h / 2 - map_h / 2;
	}
	else
	{
		source.h = viewport->h;
		target.h = viewport->h;

		source.y = player_y - viewport->h / 2;
		target.y = viewport->y;
	}

	if(source.x < 0)
	{
		source.x = 0;
	}

	if(source.y < 0)
	{
		source.y = 0;
	}

	if(source.x > map_w - source.w)
	{
		source.x = map_w - source.w;
	}

	if(source.y > map_h - source.h)
	{
		source.y = map_h - source.h;
	}





	SDL_RenderCopy(renderer, background_texture, &source, &target);
	SDL_RenderCopy(renderer, objects_texture, &source, &target);
	SDL_RenderCopy(renderer, npc_texture, &source, &target);
}