126 lines
4.1 KiB
C++
126 lines
4.1 KiB
C++
#include "sdlpp_rectcolider.hpp"
|
|
|
|
namespace SDLPP {
|
|
|
|
double RectColider::width() const {
|
|
return _size.getX();
|
|
}
|
|
|
|
double RectColider::height() const {
|
|
return _size.getY();
|
|
}
|
|
|
|
int RectColider::pixel_width() const {
|
|
return _size_pixel.getX();
|
|
}
|
|
|
|
int RectColider::pixel_height() const {
|
|
return _size_pixel.getY();
|
|
}
|
|
|
|
RectColider::RectColider( double x, double y, double w, double h )
|
|
: RectColider( { x, y }, { w, h } ) {}
|
|
|
|
RectColider::RectColider( const Vec2D< double > &top_left,
|
|
const Vec2D< double > &size )
|
|
: CollisionPolygon( top_left ), _size( size ) {}
|
|
|
|
bool RectColider::colidesWith( const SDLPP::CollisionPolygon &other ) const {
|
|
if ( other.isCircle() ) {
|
|
return other.colidesWith( *this );
|
|
}
|
|
if ( other.isInfinite() ) {
|
|
return infinityIntersection( other, *this );
|
|
}
|
|
if ( isInfinite() )
|
|
return infinityIntersection( *this, other );
|
|
return intersects( *this, other );
|
|
}
|
|
|
|
bool RectColider::isCircle() const {
|
|
return false;
|
|
}
|
|
int RectColider::topmost() const {
|
|
return ( !isInfinite() || original.getY() != -1 ) * getY() +
|
|
isInfinite() * -1;
|
|
}
|
|
int RectColider::bottommost() const {
|
|
return ( !isInfinite() || height() != -1 ) * ( getY() + pixel_height() ) +
|
|
isInfinite() * -1;
|
|
}
|
|
int RectColider::leftmost() const {
|
|
return ( !isInfinite() || original.getX() != -1 ) * getX() +
|
|
isInfinite() * -1;
|
|
}
|
|
int RectColider::rightmost() const {
|
|
return ( !isInfinite() || width() != -1 ) * ( getX() + pixel_width() ) +
|
|
isInfinite() * -1;
|
|
}
|
|
|
|
void RectColider::updateCollision( int x, int y, int w, int h ) {
|
|
position = Vec2D< int >( original.getX() * w + x, original.getY() * h + y );
|
|
_size_pixel = Vec2D< int >( width() * w, height() * h );
|
|
}
|
|
|
|
void RectColider::render( Renderer &renderer,
|
|
const std::tuple< int, int, int, int > &color ) {
|
|
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 );
|
|
}
|
|
|
|
void RectColider::render( Renderer &renderer ) {
|
|
auto rect = getRect();
|
|
SDL_SetRenderDrawColor( renderer.getRendererPtr(), sdl_color.r, sdl_color.g,
|
|
sdl_color.b, sdl_color.a );
|
|
SDL_RenderFillRect( renderer.getRendererPtr(), &rect );
|
|
SDL_SetRenderDrawColor( renderer.getRendererPtr(), sdl_outline.r,
|
|
sdl_outline.g, sdl_outline.b, sdl_outline.a );
|
|
SDL_RenderDrawRect( renderer.getRendererPtr(), &rect );
|
|
}
|
|
|
|
SDL_Rect RectColider::getRect() {
|
|
if ( !isInfinite() )
|
|
return { leftmost(), topmost(), pixel_width(), pixel_height() };
|
|
|
|
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_width();
|
|
if ( bottommost() == -1 )
|
|
r.h = std::numeric_limits< int >::max();
|
|
else
|
|
r.h = pixel_height();
|
|
return r;
|
|
}
|
|
|
|
std::shared_ptr< CollisionPolygon > RectColider::copySelf() {
|
|
return std::make_shared< RectColider >( *this );
|
|
}
|
|
|
|
std::vector< Line< double > > RectColider::getLines() {
|
|
std::vector< Line< double > > ret{};
|
|
ret.emplace_back( original, original + Vec2D< double >( width(), 0 ) );
|
|
ret.emplace_back( original + Vec2D< double >( width(), 0 ),
|
|
original + _size );
|
|
ret.emplace_back( original, original + Vec2D< double >( 0, height() ) );
|
|
ret.emplace_back( original + Vec2D< double >( 0, height() ),
|
|
original + _size );
|
|
return ret;
|
|
}
|
|
|
|
} // namespace SDLPP
|