Add text and rendering of color rectangles
This commit is contained in:
parent
618786f885
commit
329ef7f40f
2
Makefile
2
Makefile
@ -1,7 +1,7 @@
|
||||
CXX ?= g++
|
||||
CFLAGS ?= -O2 -Wall -Wextra -g
|
||||
PREFIX ?= /usr/local/bin
|
||||
LDFLAGS ?= -lSDL2 -lSDL2_image -lSDL2_gfx -pthread
|
||||
LDFLAGS ?= -lSDL2 -lSDL2_image -lSDL2_gfx -lSDL2_ttf -pthread
|
||||
|
||||
.PHONY: default
|
||||
default: demo
|
||||
|
||||
37
main.cpp
37
main.cpp
@ -10,6 +10,7 @@
|
||||
#define DESTROYABLE_DESTROY 0x00000001
|
||||
|
||||
bool pause = false;
|
||||
std::shared_ptr<SDLPP::Font> font;
|
||||
|
||||
class Player : public SDLPP::RectangleRender {
|
||||
public:
|
||||
@ -125,6 +126,10 @@ std::vector<std::shared_ptr<SDLPP::Texture>> bgtextures;
|
||||
bool quit = false;
|
||||
|
||||
void addStuff(SDLPP::Scene &scene, std::shared_ptr<SDLPP::Renderer> &r) {
|
||||
auto bg = std::make_shared<SDLPP::RectangleRender>(0,0,10,10,r,"#ebdbb2FF", true);
|
||||
bg->setId(123);
|
||||
bg->setPermanent(true);
|
||||
scene.addObject(bg);
|
||||
std::shared_ptr<Destroyable> stone;
|
||||
double posx = 0;
|
||||
while(posx < 3) {
|
||||
@ -153,6 +158,10 @@ void addStuff(SDLPP::Scene &scene, std::shared_ptr<SDLPP::Renderer> &r) {
|
||||
z->setId(DEATH);
|
||||
z->setColiderColor("FF00FF");
|
||||
scene.addObject(z);
|
||||
auto y = std::make_shared<SDLPP::RectangleRender>(0, 0, 0.2, 0.1, r);
|
||||
y->setTexture(*font, "THIS IS A TEST", "#FFFFFF", "#000000", 5);
|
||||
y->setId(0);
|
||||
scene.addObject(y);
|
||||
}
|
||||
|
||||
void quitGame() {
|
||||
@ -162,20 +171,10 @@ void quitGame() {
|
||||
|
||||
void handleKeyDown(SDL_Keycode key, SDLPP::Scene &scene) {
|
||||
switch(key) {
|
||||
case SDLK_UP:
|
||||
scene.setBackground(bgtextures[0]);
|
||||
break;
|
||||
case SDLK_DOWN:
|
||||
scene.setBackground(bgtextures[1]);
|
||||
break;
|
||||
case SDLK_RIGHT:
|
||||
scene.setBackground(bgtextures[2]);
|
||||
break;
|
||||
case SDLK_LEFT:
|
||||
scene.setBackground(bgtextures[3]);
|
||||
break;
|
||||
case SDLK_ESCAPE:
|
||||
quitGame();
|
||||
if(pause)
|
||||
scene.setPrevTicks(SDL_GetTicks());
|
||||
pause = !pause;
|
||||
break;
|
||||
case SDLK_a:
|
||||
player->addMovement(-1,0);
|
||||
@ -183,6 +182,7 @@ void handleKeyDown(SDL_Keycode key, SDLPP::Scene &scene) {
|
||||
case SDLK_d:
|
||||
player->addMovement(1,0);
|
||||
break;
|
||||
case SDLK_SPACE:
|
||||
case SDLK_w:
|
||||
if(!player->isJumping() && !pause) {
|
||||
player->setLastStand();
|
||||
@ -193,14 +193,7 @@ void handleKeyDown(SDL_Keycode key, SDLPP::Scene &scene) {
|
||||
break;
|
||||
case SDLK_r:
|
||||
scene.getRenderer().setRenderColiders(!scene.getRenderer().getRenderColiders());
|
||||
break;
|
||||
case SDLK_SPACE:
|
||||
if(pause)
|
||||
scene.setPrevTicks(SDL_GetTicks());
|
||||
pause = !pause;
|
||||
break;
|
||||
default:
|
||||
scene.setBackground(bgtextures[4]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -290,14 +283,14 @@ int main() {
|
||||
SDLPP::init();
|
||||
SDLPP::Window w("Oh yeah, boi!");
|
||||
auto renderer = std::make_shared<SDLPP::Renderer>(w);
|
||||
renderer->setBlendMode(SDL_BLENDMODE_ADD);
|
||||
renderer->setBlendMode(SDL_BLENDMODE_BLEND);
|
||||
auto main_scene = std::make_shared<SDLPP::Scene>(renderer);
|
||||
bgtextures.push_back(std::make_shared<SDLPP::Texture>(renderer, "1.bmp"));
|
||||
bgtextures.push_back(std::make_shared<SDLPP::Texture>(renderer, "2.bmp"));
|
||||
bgtextures.push_back(std::make_shared<SDLPP::Texture>(renderer, "3.png"));
|
||||
bgtextures.push_back(std::make_shared<SDLPP::Texture>(renderer, "4.png"));
|
||||
bgtextures.push_back(std::make_shared<SDLPP::Texture>(renderer, "test.bmp"));
|
||||
main_scene->setBackground(bgtextures[0]);
|
||||
font = std::make_shared<SDLPP::Font>("testfont.ttf", 24);
|
||||
addStuff(*main_scene, renderer);
|
||||
player->setMovementSpeed(0.3);
|
||||
player->enableGravity();
|
||||
|
||||
30
sdlpp.cpp
30
sdlpp.cpp
@ -12,6 +12,10 @@ bool SDLPP::init() {
|
||||
std::cerr << "SDL_image could not initialize! SDL_image Error: " << IMG_GetError() << std::endl;
|
||||
return false;
|
||||
}
|
||||
if( TTF_Init() == -1 ) {
|
||||
std::cerr << "SDL_ttf could not initialize! SDL_ttf Error: " << TTF_GetError() << std::endl;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -132,13 +136,33 @@ int SDLPP::hex2num(char c) {
|
||||
}
|
||||
}
|
||||
|
||||
std::tuple<int, int, int> SDLPP::getColorsHEX(const std::string &color) {
|
||||
int red = 0, green = 0, blue = 0;
|
||||
std::tuple<int, int, int, int> SDLPP::getColorsHEX(const std::string &color) {
|
||||
int red = 0, green = 0, blue = 0, alpha = 255;
|
||||
const char *color_ptr = color.c_str();
|
||||
if(color_ptr[0] == '#')
|
||||
color_ptr++;
|
||||
red = hex2num(color_ptr[0])*16 + hex2num(color_ptr[1]);
|
||||
green = hex2num(color_ptr[2])*16 + hex2num(color_ptr[3]);
|
||||
blue = hex2num(color_ptr[4])*16 + hex2num(color_ptr[5]);
|
||||
return {red, green, blue};
|
||||
if( color_ptr[6] != '\0' )
|
||||
alpha = hex2num(color_ptr[6])*16 + hex2num(color_ptr[7]);
|
||||
return {red, green, blue, alpha};
|
||||
}
|
||||
|
||||
SDL_Color SDLPP::getSDLColorTuple(const std::tuple<int, int, int, int> &tuple) {
|
||||
SDL_Color ret_color{};
|
||||
ret_color.r = std::get<0>(tuple);
|
||||
ret_color.g = std::get<1>(tuple);
|
||||
ret_color.b = std::get<2>(tuple);
|
||||
ret_color.a = std::get<3>(tuple);
|
||||
return ret_color;
|
||||
}
|
||||
|
||||
SDL_Color SDLPP::getSDLColorHEX(const std::string &color) {
|
||||
auto color_tuple = SDLPP::getColorsHEX(color);
|
||||
return getSDLColorTuple(color_tuple);
|
||||
}
|
||||
|
||||
std::tuple<int, int, int, int> SDLPP::getColorsSDLColor(const SDL_Color &color) {
|
||||
return {color.r, color.g, color.b, color.a};
|
||||
}
|
||||
|
||||
356
sdlpp.hpp
356
sdlpp.hpp
@ -3,6 +3,7 @@
|
||||
|
||||
#include <SDL2/SDL.h>
|
||||
#include <SDL2/SDL_image.h>
|
||||
#include <SDL2/SDL_ttf.h>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
@ -15,7 +16,10 @@ namespace SDLPP {
|
||||
|
||||
int hex2num(char c);
|
||||
|
||||
std::tuple<int, int, int> getColorsHEX(const std::string &color);
|
||||
std::tuple<int, int, int, int> getColorsHEX(const std::string &color);
|
||||
SDL_Color getSDLColorHEX(const std::string &color);
|
||||
std::tuple<int, int, int, int> getColorsSDLColor(const SDL_Color &color);
|
||||
SDL_Color getSDLColorTuple(const std::tuple<int, int, int, int> &tuple);
|
||||
|
||||
class Window {
|
||||
public:
|
||||
@ -92,6 +96,37 @@ private:
|
||||
bool render_coliders = false;
|
||||
};
|
||||
|
||||
class Font {
|
||||
public:
|
||||
Font() = delete;
|
||||
Font(const std::string &font, int size) {
|
||||
font_ptr = TTF_OpenFont(font.c_str(), size);
|
||||
}
|
||||
~Font() {
|
||||
TTF_CloseFont( font_ptr );
|
||||
}
|
||||
const TTF_Font *getFont() const {
|
||||
return font_ptr;
|
||||
}
|
||||
TTF_Font *getFont() {
|
||||
return font_ptr;
|
||||
}
|
||||
void setOutline(int size) {
|
||||
TTF_SetFontOutline(font_ptr, size);
|
||||
}
|
||||
int getOutline() {
|
||||
return TTF_GetFontOutline(font_ptr);
|
||||
}
|
||||
void setStyle(int style) {
|
||||
TTF_SetFontStyle(font_ptr, style);
|
||||
}
|
||||
void setHinting(int hinting) {
|
||||
TTF_SetFontHinting(font_ptr, hinting);
|
||||
}
|
||||
private:
|
||||
TTF_Font *font_ptr;
|
||||
};
|
||||
|
||||
class Texture {
|
||||
public:
|
||||
Texture() = delete;
|
||||
@ -106,12 +141,37 @@ public:
|
||||
auto colors = getColorsHEX(color_key);
|
||||
SDL_SetColorKey(surface, SDL_TRUE, SDL_MapRGB(surface->format, std::get<0>(colors), std::get<1>(colors), std::get<2>(colors)));
|
||||
}
|
||||
texture = SDL_CreateTextureFromSurface(renderer->getRendererPtr(), surface);
|
||||
if( texture == NULL ) {
|
||||
std::cerr << "Unable to create texture from '" << img_path << "'! SDL Error: " << SDL_GetError() << std::endl;
|
||||
throw "Texture error";
|
||||
setTextureFromSurface(renderer, surface);
|
||||
}
|
||||
Texture(std::shared_ptr<Renderer> &renderer, Font &font, const std::string &text, const std::string &color = "FFFFFF", const std::string &outline_color = "000000", const int outline_size = -1) {
|
||||
if(outline_size != -1) {
|
||||
font.setOutline(outline_size);
|
||||
}
|
||||
int og_outline = 0;
|
||||
SDL_Surface *bg_surface = NULL;
|
||||
if((og_outline = font.getOutline()) != 0) {
|
||||
bg_surface = TTF_RenderUTF8_Blended( font.getFont(), text.c_str(), getSDLColorHEX(outline_color) );
|
||||
if( bg_surface == NULL ) {
|
||||
std::cerr << "Unable to render text '" << text << "': TTF Error: " << TTF_GetError() << std::endl;
|
||||
throw "TTF_RenderUTF8_Shaded error";
|
||||
}
|
||||
font.setOutline(0);
|
||||
}
|
||||
SDL_Surface *surface = TTF_RenderUTF8_Blended( font.getFont(), text.c_str(), getSDLColorHEX(color) );
|
||||
if( surface == NULL ) {
|
||||
std::cerr << "Unable to render text '" << text << "': TTF Error: " << TTF_GetError() << std::endl;
|
||||
throw "TTF_RenderUTF8_Shaded error";
|
||||
}
|
||||
if(og_outline != 0) {
|
||||
SDL_Rect rect = {og_outline, og_outline, surface->w, surface->h};
|
||||
SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND);
|
||||
SDL_BlitSurface(surface, NULL, bg_surface, &rect);
|
||||
SDL_FreeSurface(surface);
|
||||
surface = bg_surface;
|
||||
bg_surface = NULL;
|
||||
font.setOutline(og_outline);
|
||||
}
|
||||
setTextureFromSurface(renderer, surface);
|
||||
}
|
||||
~Texture() {
|
||||
SDL_DestroyTexture(texture);
|
||||
@ -120,6 +180,14 @@ public:
|
||||
return texture;
|
||||
}
|
||||
private:
|
||||
void setTextureFromSurface(std::shared_ptr<Renderer> &renderer, SDL_Surface *surface) {
|
||||
texture = SDL_CreateTextureFromSurface(renderer->getRendererPtr(), surface);
|
||||
if( texture == NULL ) {
|
||||
std::cerr << "Unable to create texture from surface! SDL Error: " << SDL_GetError() << std::endl;
|
||||
throw "Texture error";
|
||||
}
|
||||
SDL_FreeSurface(surface);
|
||||
}
|
||||
SDL_Texture *texture = NULL;
|
||||
};
|
||||
|
||||
@ -144,19 +212,24 @@ public:
|
||||
position_x = original_x * w + x;
|
||||
position_y = original_y * h + y;
|
||||
}
|
||||
virtual void render(Renderer &renderer, const std::tuple<int,int,int> &color) = 0;
|
||||
virtual void render(Renderer &renderer, const std::tuple<int,int,int,int> &color) = 0;
|
||||
virtual void render(Renderer &renderer) = 0;
|
||||
int getX() const {
|
||||
return position_x;
|
||||
}
|
||||
int getY() const {
|
||||
return position_y;
|
||||
}
|
||||
void setColor(const std::string &color) {
|
||||
sdl_color = getSDLColorHEX(color);
|
||||
}
|
||||
protected:
|
||||
double original_x;
|
||||
double original_y;
|
||||
int position_x;
|
||||
int position_y;
|
||||
bool infinite = false;
|
||||
SDL_Color sdl_color;
|
||||
};
|
||||
|
||||
class Scene;
|
||||
@ -206,6 +279,9 @@ public:
|
||||
void setTexture(const std::string &img_path) {
|
||||
texture = std::make_shared<Texture>(renderer, img_path);
|
||||
}
|
||||
void setTexture(Font &font, const std::string &text, const std::string &color = "FFFFFF", const std::string &outline_color = "000000", int outline_size = -1) {
|
||||
texture = std::make_shared<Texture>(renderer, font, text, color, outline_color, outline_size);
|
||||
}
|
||||
// per second, relative to window width
|
||||
void setMovementSpeed(double speed) {
|
||||
movementSpeed = speed;
|
||||
@ -248,18 +324,26 @@ public:
|
||||
virtual void move(int ticks) = 0;
|
||||
virtual void updateSizeAndPosition() = 0;
|
||||
virtual SDL_Rect getRect() = 0;
|
||||
void setPermanent(bool perm) {
|
||||
permanent = perm;
|
||||
}
|
||||
bool getPermanent() const {
|
||||
return permanent;
|
||||
}
|
||||
protected:
|
||||
std::vector<std::shared_ptr<CollisionPolygon>> collisions;
|
||||
std::shared_ptr<Texture> texture;
|
||||
std::shared_ptr<Renderer> renderer;
|
||||
std::shared_ptr<CollisionPolygon> polygon;
|
||||
double movementSpeed;
|
||||
std::pair<int,int> movementDirection;
|
||||
std::vector<std::shared_ptr<RenderObject>> colidedWith;
|
||||
uint64_t id;
|
||||
bool hidden = false;
|
||||
bool kill = false;
|
||||
std::tuple<int,int,int> colider_color = {0x00, 0xFF, 0xFF};
|
||||
std::tuple<int,int,int,int> colider_color = {0x00, 0xFF, 0xFF, 0xFF};
|
||||
uint64_t scene_id;
|
||||
bool permanent = false;
|
||||
private:
|
||||
void setSceneID(int id) {
|
||||
scene_id = id;
|
||||
@ -323,6 +407,7 @@ public:
|
||||
checkKilled();
|
||||
render_mutex.lock();
|
||||
SDL_RenderClear(renderer->getRendererPtr());
|
||||
if(background && background->getTexturePtr())
|
||||
SDL_RenderCopy(renderer->getRendererPtr(), background->getTexturePtr(), NULL, NULL);
|
||||
for( const auto &x : renderObjects ) {
|
||||
x->render();
|
||||
@ -405,6 +490,133 @@ private:
|
||||
std::mutex render_mutex;
|
||||
};
|
||||
|
||||
class Rect : public CollisionPolygon {
|
||||
public:
|
||||
Rect(double x, double y, double w, double h) : CollisionPolygon(x, y) {
|
||||
w_ = w;
|
||||
h_ = h;
|
||||
}
|
||||
virtual ~Rect() {}
|
||||
virtual bool colidesWith(const CollisionPolygon &other) const override;
|
||||
virtual bool isCircle() const override { return false; }
|
||||
virtual int topmost() const override {
|
||||
return (!isInfinite() || original_y != -1) * getY() + isInfinite() * -1;
|
||||
}
|
||||
virtual int bottommost() const override {
|
||||
return (!isInfinite() || h_ != -1) * (getY() + pixel_h) + isInfinite() * -1;
|
||||
};
|
||||
virtual int leftmost() const override {
|
||||
return (!isInfinite() || original_x != -1) * getX() + isInfinite() * -1;
|
||||
}
|
||||
virtual int rightmost() const override {
|
||||
return (!isInfinite() || w_ != -1) * (getX() + pixel_w) + isInfinite() * -1;
|
||||
}
|
||||
virtual void updateCollision(int x, int y, int w, int h) override {
|
||||
position_x = original_x * w + x;
|
||||
position_y = original_y * h + y;
|
||||
pixel_w = w_ * w;
|
||||
pixel_h = h_ * h;
|
||||
}
|
||||
virtual void render(Renderer &renderer, const std::tuple<int,int,int,int> &color) override {
|
||||
auto rect = getRect();
|
||||
// outline with desired color at 50% opacity
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x80);
|
||||
SDL_RenderDrawRect(renderer.getRendererPtr(), &rect);
|
||||
// fill with desired color at 25% opacity
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x40);
|
||||
SDL_RenderFillRect(renderer.getRendererPtr(), &rect);
|
||||
}
|
||||
virtual void render(Renderer &renderer) override {
|
||||
auto rect = getRect();
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a);
|
||||
SDL_RenderFillRect(renderer.getRendererPtr(), &rect);
|
||||
}
|
||||
private:
|
||||
SDL_Rect getRect() {
|
||||
if( !isInfinite() )
|
||||
return {leftmost(), topmost(), pixel_w, pixel_h};
|
||||
|
||||
SDL_Rect r = {0,0,0,0};
|
||||
if((r.x = leftmost()) == -1)
|
||||
r.x = 0;
|
||||
if((r.y = topmost()) == -1)
|
||||
r.y = 0;
|
||||
if(rightmost() == -1)
|
||||
r.w = std::numeric_limits<int>::max();
|
||||
else
|
||||
r.w = pixel_w;
|
||||
if(bottommost() == -1)
|
||||
r.h = std::numeric_limits<int>::max();
|
||||
else
|
||||
r.h = pixel_h;
|
||||
return r;
|
||||
}
|
||||
|
||||
double w_;
|
||||
double h_;
|
||||
int pixel_w;
|
||||
int pixel_h;
|
||||
};
|
||||
|
||||
class Circle : public CollisionPolygon {
|
||||
public:
|
||||
Circle(double x, double y, double rad) : CollisionPolygon(x, y) {
|
||||
original_rad = rad;
|
||||
}
|
||||
virtual ~Circle() {}
|
||||
virtual bool colidesWith(const CollisionPolygon &other) const override;
|
||||
virtual bool isCircle() const override { return true; }
|
||||
virtual int topmost() const override { return getY() - rad_; }
|
||||
virtual int bottommost() const override { return getY() + rad_; };
|
||||
virtual int leftmost() const override { return getX() - rad_; }
|
||||
virtual int rightmost() const override { return getX() + rad_; }
|
||||
virtual void updateCollision(int x, int y, int w, int h) override {
|
||||
position_x = original_x * w + x;
|
||||
position_y = original_y * h + y;
|
||||
rad_ = original_rad * w;
|
||||
}
|
||||
virtual void render(Renderer &renderer, const std::tuple<int,int,int,int> &color) override {
|
||||
std::vector<int> rect = {leftmost(), topmost(), rightmost(), bottommost()};
|
||||
auto center_x = getX();
|
||||
auto center_y = getY();
|
||||
auto radsq = rad_ * rad_;
|
||||
for(int i = rect[0]; i <= rect[2]; i++) {
|
||||
auto xdiff = center_x - i;
|
||||
auto xdist = xdiff * xdiff;
|
||||
auto allowed_rad = sqrt(radsq - xdist);
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x40);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y - allowed_rad, i, center_y + allowed_rad);
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x80);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y - allowed_rad, i, center_y - allowed_rad + 2);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y + allowed_rad, i, center_y + allowed_rad - 2);
|
||||
}
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), 0xFF, 0, 0, 0xFF);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x + rad_, center_y);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x, center_y + rad_);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x - rad_, center_y);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x, center_y - rad_);
|
||||
}
|
||||
virtual void render(Renderer &renderer) override {
|
||||
std::vector<int> rect = {leftmost(), topmost(), rightmost(), bottommost()};
|
||||
auto center_x = getX();
|
||||
auto center_y = getY();
|
||||
auto radsq = rad_ * rad_;
|
||||
for(int i = rect[0]; i <= rect[2]; i++) {
|
||||
auto xdiff = center_x - i;
|
||||
auto xdist = xdiff * xdiff;
|
||||
auto allowed_rad = sqrt(radsq - xdist);
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), sdl_color.r, sdl_color.g, sdl_color.b, sdl_color.a);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y - allowed_rad, i, center_y + allowed_rad);
|
||||
}
|
||||
}
|
||||
private:
|
||||
int getRadius() const {
|
||||
return rad_;
|
||||
}
|
||||
double original_rad;
|
||||
int rad_;
|
||||
};
|
||||
|
||||
class RectangleRender : public RenderObject {
|
||||
public:
|
||||
RectangleRender() = delete;
|
||||
@ -420,12 +632,18 @@ public:
|
||||
w_ = w;
|
||||
h_ = h;
|
||||
}
|
||||
RectangleRender(int x, int y, int w, int h, std::shared_ptr<Renderer> &r, std::shared_ptr<Texture> &t) : RectangleRender(x, y, w, h, r) {
|
||||
RectangleRender(double x, double y, double w, double h, std::shared_ptr<Renderer> &r, std::shared_ptr<Texture> &t) : RectangleRender(x, y, w, h, r) {
|
||||
setTexture(t);
|
||||
}
|
||||
RectangleRender(int x, int y, int w, int h, std::shared_ptr<Renderer> &r, const std::string &img_path) : RectangleRender(x,y,w,h,r) {
|
||||
auto texture = std::make_shared<Texture>(r, img_path);
|
||||
RectangleRender(double x, double y, double w, double h, std::shared_ptr<Renderer> &r, const std::string &img_or_color, bool is_polygon = false) : RectangleRender(x,y,w,h,r) {
|
||||
if(!is_polygon) {
|
||||
auto texture = std::make_shared<Texture>(r, img_or_color);
|
||||
setTexture(texture);
|
||||
} else {
|
||||
polygon = std::make_shared<Rect>(0,0,1,1);
|
||||
polygon->setColor(img_or_color);
|
||||
polygon->updateCollision(collisionPushX(), collisionPushY(), collisionWidth(), collisionHeight());
|
||||
}
|
||||
}
|
||||
virtual void specialAction(int /*UNUSED*/) {};
|
||||
virtual void render() {
|
||||
@ -435,8 +653,13 @@ public:
|
||||
for(const auto &col : getCollisions())
|
||||
col->render(*renderer, colider_color);
|
||||
}
|
||||
if(polygon) {
|
||||
polygon->render(*renderer);
|
||||
}
|
||||
}
|
||||
virtual void move(int ticks) {
|
||||
if(permanent)
|
||||
return;
|
||||
auto dimension = renderer->getSmallerSide();
|
||||
auto addx = static_cast<double>(movementSpeed * movementDirection.first)*(static_cast<double>(ticks)/1000);
|
||||
auto addy = static_cast<double>(movementSpeed * movementDirection.second)*(static_cast<double>(ticks)/1000);
|
||||
@ -447,6 +670,8 @@ public:
|
||||
for( auto &x : collisions ) {
|
||||
x->updateCollision(collisionPushX(), collisionPushY(), collisionWidth(), collisionHeight());
|
||||
}
|
||||
if(polygon)
|
||||
polygon->updateCollision(collisionPushX(), collisionPushY(), collisionWidth(), collisionHeight());
|
||||
}
|
||||
virtual std::pair<std::pair<double,double>,std::pair<double,double>> getDoubleRect() {
|
||||
return {{x_,y_}, {w_,h_}};
|
||||
@ -488,6 +713,8 @@ public:
|
||||
rect.y = y_ * dimension;
|
||||
rect.w = w_ * dimension;
|
||||
rect.h = h_ * dimension;
|
||||
if(polygon)
|
||||
polygon->updateCollision(collisionPushX(), collisionPushY(), collisionWidth(), collisionHeight());
|
||||
}
|
||||
virtual SDL_Rect getRect() {
|
||||
return rect;
|
||||
@ -535,115 +762,6 @@ private:
|
||||
int rad_;
|
||||
};
|
||||
|
||||
class Rect : public CollisionPolygon {
|
||||
public:
|
||||
Rect(double x, double y, double w, double h) : CollisionPolygon(x, y) {
|
||||
w_ = w;
|
||||
h_ = h;
|
||||
}
|
||||
virtual ~Rect() {}
|
||||
virtual bool colidesWith(const CollisionPolygon &other) const override;
|
||||
virtual bool isCircle() const override { return false; }
|
||||
virtual int topmost() const override {
|
||||
return (!isInfinite() || original_y != -1) * getY() + isInfinite() * -1;
|
||||
}
|
||||
virtual int bottommost() const override {
|
||||
return (!isInfinite() || h_ != -1) * (getY() + pixel_h) + isInfinite() * -1;
|
||||
};
|
||||
virtual int leftmost() const override {
|
||||
return (!isInfinite() || original_x != -1) * getX() + isInfinite() * -1;
|
||||
}
|
||||
virtual int rightmost() const override {
|
||||
return (!isInfinite() || w_ != -1) * (getX() + pixel_w) + isInfinite() * -1;
|
||||
}
|
||||
virtual void updateCollision(int x, int y, int w, int h) override {
|
||||
position_x = original_x * w + x;
|
||||
position_y = original_y * h + y;
|
||||
pixel_w = w_ * w;
|
||||
pixel_h = h_ * h;
|
||||
}
|
||||
virtual void render(Renderer &renderer, const std::tuple<int,int,int> &color) override {
|
||||
auto rect = getRect();
|
||||
// outline with desired color at 50% opacity
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x80);
|
||||
SDL_RenderDrawRect(renderer.getRendererPtr(), &rect);
|
||||
// fill with desired color at 25% opacity
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x40);
|
||||
SDL_RenderFillRect(renderer.getRendererPtr(), &rect);
|
||||
}
|
||||
private:
|
||||
SDL_Rect getRect() {
|
||||
if( !isInfinite() )
|
||||
return {leftmost(), topmost(), pixel_w, pixel_h};
|
||||
|
||||
SDL_Rect r = {0,0,0,0};
|
||||
if((r.x = leftmost()) == -1)
|
||||
r.x = 0;
|
||||
if((r.y = topmost()) == -1)
|
||||
r.y = 0;
|
||||
if(rightmost() == -1)
|
||||
r.w = std::numeric_limits<int>::max();
|
||||
else
|
||||
r.w = pixel_w;
|
||||
if(bottommost() == -1)
|
||||
r.h = std::numeric_limits<int>::max();
|
||||
else
|
||||
r.h = pixel_h;
|
||||
return r;
|
||||
}
|
||||
|
||||
double w_;
|
||||
double h_;
|
||||
int pixel_w;
|
||||
int pixel_h;
|
||||
};
|
||||
|
||||
class Circle : public CollisionPolygon {
|
||||
public:
|
||||
Circle(double x, double y, double rad) : CollisionPolygon(x, y) {
|
||||
original_rad = rad;
|
||||
}
|
||||
virtual ~Circle() {}
|
||||
virtual bool colidesWith(const CollisionPolygon &other) const override;
|
||||
virtual bool isCircle() const override { return true; }
|
||||
virtual int topmost() const override { return getY() - rad_; }
|
||||
virtual int bottommost() const override { return getY() + rad_; };
|
||||
virtual int leftmost() const override { return getX() - rad_; }
|
||||
virtual int rightmost() const override { return getX() + rad_; }
|
||||
virtual void updateCollision(int x, int y, int w, int h) override {
|
||||
position_x = original_x * w + x;
|
||||
position_y = original_y * h + y;
|
||||
rad_ = original_rad * w;
|
||||
}
|
||||
virtual void render(Renderer &renderer, const std::tuple<int,int,int> &color) override {
|
||||
std::vector<int> rect = {leftmost(), topmost(), rightmost(), bottommost()};
|
||||
auto center_x = getX();
|
||||
auto center_y = getY();
|
||||
auto radsq = rad_ * rad_;
|
||||
for(int i = rect[0]; i <= rect[2]; i++) {
|
||||
auto xdiff = center_x - i;
|
||||
auto xdist = xdiff * xdiff;
|
||||
auto allowed_rad = sqrt(radsq - xdist);
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x40);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y - allowed_rad, i, center_y + allowed_rad);
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), std::get<0>(color), std::get<1>(color), std::get<2>(color), 0x80);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y - allowed_rad, i, center_y - allowed_rad + 2);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), i, center_y + allowed_rad, i, center_y + allowed_rad - 2);
|
||||
}
|
||||
SDL_SetRenderDrawColor(renderer.getRendererPtr(), 0xFF, 0, 0, 0xFF);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x + rad_, center_y);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x, center_y + rad_);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x - rad_, center_y);
|
||||
SDL_RenderDrawLine(renderer.getRendererPtr(), center_x, center_y, center_x, center_y - rad_);
|
||||
}
|
||||
private:
|
||||
int getRadius() const {
|
||||
return rad_;
|
||||
}
|
||||
double original_rad;
|
||||
int rad_;
|
||||
};
|
||||
|
||||
bool init();
|
||||
bool init(uint32_t SDL_OPTIONS);
|
||||
bool init(uint32_t SDL_OPTIONS, int IMAGE_OPTIONS);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user