2020-11-22 20:58:37 +00:00
|
|
|
#include <cmath>
|
2020-11-21 19:57:40 +00:00
|
|
|
#include "sdlpp_rectrenderer.hpp"
|
|
|
|
|
|
|
|
namespace SDLPP {
|
|
|
|
RectangleRender::RectangleRender( double x, double y, double w, double h,
|
|
|
|
const std::shared_ptr< Renderer > &r )
|
|
|
|
: RenderObject( r ) {
|
|
|
|
og_x = x_ = x;
|
|
|
|
og_y = y_ = y;
|
|
|
|
og_w = w_ = w;
|
|
|
|
og_h = h_ = h;
|
|
|
|
updateSizeAndPosition();
|
|
|
|
}
|
|
|
|
RectangleRender::RectangleRender( double x, double y, double w, double h,
|
|
|
|
const std::shared_ptr< Renderer > &r,
|
2021-03-07 12:06:08 +00:00
|
|
|
const std::shared_ptr< Texture > &t,
|
|
|
|
int source_x, int source_y, int source_width,
|
|
|
|
int source_height )
|
2020-11-21 19:57:40 +00:00
|
|
|
: RectangleRender( x, y, w, h, r ) {
|
2021-03-07 12:06:08 +00:00
|
|
|
setTexture( t, source_x, source_y, source_width, source_height );
|
|
|
|
}
|
|
|
|
RectangleRender::RectangleRender( double x, double y, double w, double h,
|
|
|
|
const std::shared_ptr< Renderer > &r,
|
|
|
|
const std::shared_ptr< Texture > &t,
|
2021-03-07 13:06:55 +00:00
|
|
|
const SDL_Rect &source_rect )
|
2021-03-07 12:06:08 +00:00
|
|
|
: RectangleRender( x, y, w, h, r ) {
|
|
|
|
setTexture( t, source_rect );
|
2020-11-21 19:57:40 +00:00
|
|
|
}
|
|
|
|
RectangleRender::RectangleRender( double x, double y, double w, double h,
|
|
|
|
const std::shared_ptr< Renderer > &r,
|
|
|
|
const std::string &img_or_color,
|
|
|
|
bool is_polygon )
|
|
|
|
: RectangleRender( x, y, w, h, r ) {
|
|
|
|
if ( !is_polygon ) {
|
|
|
|
setTexture( img_or_color );
|
|
|
|
} else {
|
|
|
|
setColor( img_or_color );
|
|
|
|
color = img_or_color;
|
|
|
|
}
|
|
|
|
}
|
2021-03-07 12:06:08 +00:00
|
|
|
RectangleRender::RectangleRender( double x, double y, double w, double h,
|
|
|
|
const std::shared_ptr< Renderer > &r,
|
|
|
|
const std::string &img, int source_x,
|
|
|
|
int source_y, int source_width,
|
|
|
|
int source_height )
|
|
|
|
: RectangleRender( x, y, w, h, r ) {
|
|
|
|
setTexture( img, source_x, source_y, source_width, source_height );
|
|
|
|
}
|
|
|
|
RectangleRender::RectangleRender( double x, double y, double w, double h,
|
|
|
|
const std::shared_ptr< Renderer > &r,
|
2021-03-07 13:06:55 +00:00
|
|
|
const std::string &img,
|
|
|
|
const SDL_Rect &source_rect )
|
2021-03-07 12:06:08 +00:00
|
|
|
: RectangleRender( x, y, w, h, r ) {
|
|
|
|
setTexture( img, source_rect );
|
|
|
|
}
|
2020-11-21 19:57:40 +00:00
|
|
|
void RectangleRender::setColor( const std::string &color ) {
|
|
|
|
if ( !polygon ) {
|
|
|
|
polygon = std::make_shared< RectColider >( 0, 0, 1, 1 );
|
|
|
|
polygon->updateCollision( collisionPushX(), collisionPushY(),
|
|
|
|
collisionWidth(), collisionHeight() );
|
|
|
|
}
|
|
|
|
polygon->setColor( color );
|
|
|
|
}
|
|
|
|
void RectangleRender::setOutlineColor( const std::string &color ) {
|
|
|
|
if ( !polygon ) {
|
|
|
|
polygon = std::make_shared< RectColider >( 0, 0, 1, 1 );
|
|
|
|
polygon->updateCollision( collisionPushX(), collisionPushY(),
|
|
|
|
collisionWidth(), collisionHeight() );
|
|
|
|
}
|
|
|
|
polygon->setOutlineColor( color );
|
|
|
|
}
|
|
|
|
std::pair< std::pair< double, double >, std::pair< double, double > >
|
|
|
|
RectangleRender::getDoubleRect() const {
|
|
|
|
return { { og_x, og_y }, { og_w, og_h } };
|
|
|
|
}
|
|
|
|
int RectangleRender::leftmost() {
|
|
|
|
return rect.x;
|
|
|
|
}
|
|
|
|
int RectangleRender::topmost() {
|
|
|
|
return rect.y;
|
|
|
|
}
|
|
|
|
int RectangleRender::rightmost() {
|
|
|
|
return rect.x + rect.w;
|
|
|
|
}
|
|
|
|
int RectangleRender::bottommost() {
|
|
|
|
return rect.y + rect.h;
|
|
|
|
}
|
|
|
|
int RectangleRender::collisionPushX() {
|
|
|
|
return rect.x;
|
|
|
|
}
|
|
|
|
int RectangleRender::collisionPushY() {
|
|
|
|
return rect.y;
|
|
|
|
}
|
|
|
|
int RectangleRender::collisionWidth() {
|
|
|
|
return rect.w;
|
|
|
|
}
|
|
|
|
int RectangleRender::collisionHeight() {
|
|
|
|
return rect.h;
|
|
|
|
}
|
|
|
|
void RectangleRender::updateSizeAndPosition() {
|
|
|
|
updateXY();
|
|
|
|
auto dimension = renderer->getSmallerSide();
|
|
|
|
rect.x = std::round( x_ * dimension );
|
|
|
|
rect.y = std::round( y_ * dimension );
|
|
|
|
rect.w = std::round( ( x_ + w_ ) * dimension ) - rect.x;
|
|
|
|
rect.h = std::round( ( y_ + h_ ) * dimension ) - rect.y;
|
|
|
|
if ( polygon )
|
|
|
|
polygon->updateCollision( collisionPushX(), collisionPushY(),
|
|
|
|
collisionWidth(), collisionHeight() );
|
|
|
|
for ( auto &x : collisions ) {
|
|
|
|
x->updateCollision( collisionPushX(), collisionPushY(),
|
|
|
|
collisionWidth(), collisionHeight() );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SDL_Rect RectangleRender::getRect() {
|
|
|
|
return rect;
|
|
|
|
}
|
|
|
|
void RectangleRender::centerX() {
|
|
|
|
centerx = true;
|
|
|
|
updateSizeAndPosition();
|
|
|
|
}
|
|
|
|
std::shared_ptr< RenderObject > RectangleRender::copySelf() {
|
2020-12-18 15:02:02 +00:00
|
|
|
auto ret = std::make_shared< RectangleRender >( *this );
|
2021-03-07 12:06:08 +00:00
|
|
|
copyTo( ret );
|
2020-12-18 15:02:02 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2021-03-07 12:06:08 +00:00
|
|
|
void RectangleRender::copyTo( std::shared_ptr< RenderObject > other ) {
|
|
|
|
RenderObject::copyTo( other );
|
2020-11-21 19:57:40 +00:00
|
|
|
}
|
|
|
|
std::string RectangleRender::getColor() const {
|
|
|
|
return color;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RectangleRender::updateXY() {
|
|
|
|
if ( !centerx ) {
|
|
|
|
x_ = og_x;
|
|
|
|
y_ = og_y;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
auto width = renderer->getWidth();
|
|
|
|
auto height = renderer->getHeight();
|
|
|
|
if ( width > height ) {
|
|
|
|
auto multiplier =
|
|
|
|
static_cast< double >( width ) / static_cast< double >( height );
|
|
|
|
x_ = og_x + static_cast< double >( multiplier - 1 ) / 2;
|
|
|
|
} else {
|
|
|
|
x_ = og_x;
|
|
|
|
}
|
|
|
|
y_ = og_y;
|
|
|
|
}
|
|
|
|
} // namespace SDLPP
|