Relintai/programming_tutorials
1
0
Fork 0
mirror of https://github.com/Relintai/programming_tutorials.git synced 2025-05-11 22:52:11 +02:00
Code Issues Packages Projects Releases Wiki Activity

Renderer uml cleanup.

Browse Source
This commit is contained in:
Relintai 2021-04-07 18:44:20 +02:00
parent 1db550fcbe
commit f2d1e01b11
1 changed files with 230 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

452
17_sdl_renderer.txt
View File

@ -1,87 +1,95 @@
Írjunk egy renderer oszályt.
class Renderer |---------------------------------------------------------------------------------------|
| class Renderer |
void present(); |---------------------------------------------------------------------------------------|
void set_draw_color(const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a); | + void present() |
void set_draw_color(const Color &color); | + void set_draw_color(const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a) |
void clear(); | + void set_draw_color(const Color &color) |
| + void clear() |
SDL_BlendMode get_blend_mode() const; | |
void set_blend_mode(const SDL_BlendMode mode); | + SDL_BlendMode get_blend_mode() const |
| + void set_blend_mode(const SDL_BlendMode mode) |
void draw_point(const int x, const int y); | |
void draw_point(const float x, const float y); | + void draw_point(const int x, const int y) |
| + void draw_point(const float x, const float y) |
void draw_line(const int x1, const int x2, const int y1, const int y2); | |
void draw_line(const float x1, const float x2, const float y1, const float y2); | + void draw_line(const int x1, const int x2, const int y1, const int y2) |
| + void draw_line(const float x1, const float x2, const float y1, const float y2) |
void draw_rect(const Rect2 &rect); | |
| + void draw_rect(const Rect2 &rect) |
void draw_fill_rect(const Rect2 &rect); | |
| + void draw_fill_rect(const Rect2 &rect) |
void draw_texture(const Texture &texture, const Rect2 &dst_rect); | |
void draw_texture(const Texture &texture, const Rect2 &src_rect, const Rect2 &dst_rect); | + void draw_texture(const Texture &texture, const Rect2 &dst_rect) |
void draw_texture(const Texture &texture, const Rect2 &src_rect, const Rect2 &dst_rect, const double angle, const float cx = 0, const float cy = 0, const SDL_RendererFlip flip = SDL_FLIP_NONE); | + void draw_texture(const Texture &texture, const Rect2 &src_rect, |
| const Rect2 &dst_rect) |
void draw_sprite(const Sprite &sprite); | |
void draw_sprite(const Sprite *sprite); | + void draw_texture(const Texture &texture, const Rect2 &src_rect, |
| const Rect2 &dst_rect, const double angle, const float cx = 0, |
int get_dpi() const; | const float cy = 0, const SDL_RendererFlip flip = SDL_FLIP_NONE)|
int get_window_size_w() const; | |
int get_window_size_h() const; | + void draw_sprite(const Sprite &sprite) |
int get_size_w() const; | + void draw_sprite(const Sprite *sprite) |
int get_size_h() const; | |
void set_size(const int w, const int h) const; | + int get_dpi() const |
void get_size(int *w, int *h) const; | + int get_window_size_w() const |
| + int get_window_size_h() const |
float get_scale_w() const; | + int get_size_w() const |
float get_scale_h() const; | + int get_size_h() const |
void set_scale(const float w, const float h) const; | + void set_size(const int w, const int h) const |
void get_scale(float *w, float *h) const; | + void get_size(int *w, int *h) const |
| |
bool get_integer_scaling() const; | + float get_scale_w() const |
void set_integer_scaling(const bool enable); | + float get_scale_h() const |
| + void set_scale(const float w, const float h) const |
Rect2 get_viewport() const; | + void get_scale(float *w, float *h) const |
void set_viewport(const Rect2 &rect) const; | |
| + bool get_integer_scaling() const |
Rect2 get_clip_rect() const; | + void set_integer_scaling(const bool enable) |
void set_clip_rect(Rect2 *rect) const; | |
bool clip_rect_enabled() const; | + Rect2 get_viewport() const |
| + void set_viewport(const Rect2 &rect) const |
bool render_target_supported(); | |
| + Rect2 get_clip_rect() const |
SDL_Texture *get_render_target(); | + void set_clip_rect(Rect2 *rect) const |
void set_render_target(Texture *texture); | + bool clip_rect_enabled() const |
| |
void initialize(); | + bool render_target_supported() |
void destroy(); | |
| + SDL_Texture *get_render_target() |
SDL_Window *get_window(); | + void set_render_target(Texture *texture) |
SDL_Renderer *get_renderer(); | |
| + void initialize() |
Renderer(); | + void destroy() |
Renderer(unsigned int flags, unsigned int window_flags, int window_width = 640, int window_height = 480); | |
virtual ~Renderer(); | + SDL_Window *get_window() |
| + SDL_Renderer *get_renderer() |
static Renderer *get_singleton(); | |
| + Renderer() |
private: | + Renderer(unsigned int flags, unsigned int window_flags, int window_width = 640, |
int _initial_window_width; | int window_height = 480) |
int _initial_window_height; | |
| + virtual ~Renderer() |
unsigned int _flags; | |
unsigned int _window_flags; | + static Renderer *get_singleton() |
| |
SDL_Window *_window; | - int _initial_window_width |
SDL_Renderer *_renderer; | - int _initial_window_height |
| |
int _window_display_index; | - unsigned int _flags |
| - unsigned int _window_flags |
static Renderer *_singleton; | |
| - SDL_Window *_window |
| - SDL_Renderer *_renderer |
| |
| - int _window_display_index |
| |
| - static Renderer *_singleton |
|---------------------------------------------------------------------------------------|
@ -92,365 +100,365 @@ private:
#include "math.h" #include "math.h"
void Renderer::present() { void Renderer::present() {
SDL_RenderPresent(_renderer); SDL_RenderPresent(_renderer)
} }
void Renderer::set_draw_color(const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a) { void Renderer::set_draw_color(const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a) {
SDL_SetRenderDrawColor(_renderer, r, g, b, a); SDL_SetRenderDrawColor(_renderer, r, g, b, a)
} }
void Renderer::set_draw_color(const Color &color) { void Renderer::set_draw_color(const Color &color) {
SDL_SetRenderDrawColor(_renderer, color.r, color.g, color.b, color.a); SDL_SetRenderDrawColor(_renderer, color.r, color.g, color.b, color.a)
} }
void Renderer::clear() { void Renderer::clear() {
SDL_RenderClear(_renderer); SDL_RenderClear(_renderer)
} }
SDL_BlendMode Renderer::get_blend_mode() const { SDL_BlendMode Renderer::get_blend_mode() const {
SDL_BlendMode mode; SDL_BlendMode mode
SDL_GetRenderDrawBlendMode(_renderer, &mode); SDL_GetRenderDrawBlendMode(_renderer, &mode)
return mode; return mode
} }
void Renderer::set_blend_mode(const SDL_BlendMode mode) { void Renderer::set_blend_mode(const SDL_BlendMode mode) {
SDL_SetRenderDrawBlendMode(_renderer, mode); SDL_SetRenderDrawBlendMode(_renderer, mode)
} }
void Renderer::draw_point(const int x, const int y) { void Renderer::draw_point(const int x, const int y) {
SDL_RenderDrawPoint(_renderer, x, y); SDL_RenderDrawPoint(_renderer, x, y)
} }
void Renderer::draw_point(const float x, const float y) { void Renderer::draw_point(const float x, const float y) {
SDL_RenderDrawPointF(_renderer, x, y); SDL_RenderDrawPointF(_renderer, x, y)
} }
void Renderer::draw_line(const int x1, const int x2, const int y1, const int y2) { void Renderer::draw_line(const int x1, const int x2, const int y1, const int y2) {
SDL_RenderDrawLine(_renderer, x1, x2, y1, y2); SDL_RenderDrawLine(_renderer, x1, x2, y1, y2)
} }
void Renderer::draw_line(const float x1, const float x2, const float y1, const float y2) { void Renderer::draw_line(const float x1, const float x2, const float y1, const float y2) {
SDL_RenderDrawLineF(_renderer, x1, x2, y1, y2); SDL_RenderDrawLineF(_renderer, x1, x2, y1, y2)
} }
void Renderer::draw_rect(const Rect2 &rect) { void Renderer::draw_rect(const Rect2 &rect) {
SDL_Rect r = rect.as_rect(); SDL_Rect r = rect.as_rect()
SDL_RenderDrawRect(_renderer, &r); SDL_RenderDrawRect(_renderer, &r)
} }
void Renderer::draw_fill_rect(const Rect2 &rect) { void Renderer::draw_fill_rect(const Rect2 &rect) {
SDL_Rect r = rect.as_rect(); SDL_Rect r = rect.as_rect()
SDL_RenderFillRect(_renderer, &r); SDL_RenderFillRect(_renderer, &r)
} }
void Renderer::draw_texture(const Texture &texture, const Rect2 &dst_rect) { void Renderer::draw_texture(const Texture &texture, const Rect2 &dst_rect) {
SDL_Rect sr; SDL_Rect sr
sr.x = 0; sr.x = 0
sr.y = 0; sr.y = 0
sr.w = texture.get_width(); sr.w = texture.get_width()
sr.h = texture.get_height(); sr.h = texture.get_height()
SDL_Rect dr = dst_rect.as_rect(); SDL_Rect dr = dst_rect.as_rect()
SDL_RenderCopy(_renderer, texture.get_texture(), &sr, &dr); SDL_RenderCopy(_renderer, texture.get_texture(), &sr, &dr)
} }
void Renderer::draw_texture(const Texture &texture, const Rect2 &src_rect, const Rect2 &dst_rect) { void Renderer::draw_texture(const Texture &texture, const Rect2 &src_rect, const Rect2 &dst_rect) {
SDL_Rect sr = src_rect.as_rect(); SDL_Rect sr = src_rect.as_rect()
SDL_Rect dr = dst_rect.as_rect(); SDL_Rect dr = dst_rect.as_rect()
SDL_RenderCopy(_renderer, texture.get_texture(), &sr, &dr); SDL_RenderCopy(_renderer, texture.get_texture(), &sr, &dr)
} }
void Renderer::draw_texture(const Texture &texture, const Rect2 &src_rect, const Rect2 &dst_rect, const double angle, const float cx, const float cy, const SDL_RendererFlip flip) { void Renderer::draw_texture(const Texture &texture, const Rect2 &src_rect, const Rect2 &dst_rect, const double angle, const float cx, const float cy, const SDL_RendererFlip flip) {
SDL_Rect sr = src_rect.as_rect(); SDL_Rect sr = src_rect.as_rect()
SDL_FRect dr = dst_rect.as_frect(); SDL_FRect dr = dst_rect.as_frect()
SDL_FPoint p; SDL_FPoint p
p.x = cx; p.x = cx
p.y = cy; p.y = cy
SDL_RenderCopyExF(_renderer, texture.get_texture(), &sr, &dr, angle, &p, flip); SDL_RenderCopyExF(_renderer, texture.get_texture(), &sr, &dr, angle, &p, flip)
} }
void Renderer::draw_sprite(const Sprite &sprite) { void Renderer::draw_sprite(const Sprite &sprite) {
Texture *t = sprite.get_texture(); Texture *t = sprite.get_texture()
if (!t) { if (!t) {
return; return
} }
t->set_color_mod(sprite.get_color_mod()); t->set_color_mod(sprite.get_color_mod())
double angle = sprite.get_angle(); double angle = sprite.get_angle()
if (Math::is_zero_approx(angle)) { if (Math::is_zero_approx(angle)) {
SDL_Rect sr = sprite.get_texture_clip_rect().as_rect(); SDL_Rect sr = sprite.get_texture_clip_rect().as_rect()
SDL_Rect dr = sprite.get_transform().as_rect(); SDL_Rect dr = sprite.get_transform().as_rect()
SDL_RenderCopy(_renderer, t->get_texture(), &sr, &dr); SDL_RenderCopy(_renderer, t->get_texture(), &sr, &dr)
} else { } else {
SDL_Rect sr = sprite.get_texture_clip_rect().as_rect(); SDL_Rect sr = sprite.get_texture_clip_rect().as_rect()
SDL_FRect dr = sprite.get_transform().as_frect(); SDL_FRect dr = sprite.get_transform().as_frect()
SDL_FPoint p; SDL_FPoint p
p.x = sprite.get_anchor_x(); p.x = sprite.get_anchor_x()
p.y = sprite.get_anchor_y(); p.y = sprite.get_anchor_y()
SDL_RenderCopyExF(_renderer, t->get_texture(), &sr, &dr, angle, &p, sprite.get_flip()); SDL_RenderCopyExF(_renderer, t->get_texture(), &sr, &dr, angle, &p, sprite.get_flip())
} }
} }
void Renderer::draw_sprite(const Sprite *sprite) { void Renderer::draw_sprite(const Sprite *sprite) {
if (!sprite) if (!sprite)
return; return
Texture *t = sprite->get_texture(); Texture *t = sprite->get_texture()
if (!t) { if (!t) {
return; return
} }
t->set_color_mod(sprite->get_color_mod()); t->set_color_mod(sprite->get_color_mod())
double angle = sprite->get_angle(); double angle = sprite->get_angle()
if (Math::is_zero_approx(angle)) { if (Math::is_zero_approx(angle)) {
SDL_Rect sr = sprite->get_texture_clip_rect().as_rect(); SDL_Rect sr = sprite->get_texture_clip_rect().as_rect()
SDL_Rect dr = sprite->get_transform().as_rect(); SDL_Rect dr = sprite->get_transform().as_rect()
SDL_RenderCopy(_renderer, t->get_texture(), &sr, &dr); SDL_RenderCopy(_renderer, t->get_texture(), &sr, &dr)
} else { } else {
SDL_Rect sr = sprite->get_texture_clip_rect().as_rect(); SDL_Rect sr = sprite->get_texture_clip_rect().as_rect()
SDL_FRect dr = sprite->get_transform().as_frect(); SDL_FRect dr = sprite->get_transform().as_frect()
SDL_FPoint p; SDL_FPoint p
p.x = sprite->get_anchor_x(); p.x = sprite->get_anchor_x()
p.y = sprite->get_anchor_y(); p.y = sprite->get_anchor_y()
SDL_RenderCopyExF(_renderer, t->get_texture(), &sr, &dr, angle, &p, sprite->get_flip()); SDL_RenderCopyExF(_renderer, t->get_texture(), &sr, &dr, angle, &p, sprite->get_flip())
} }
} }
int Renderer::get_dpi() const { int Renderer::get_dpi() const {
float ddpi; float ddpi
float hdpi; float hdpi
float vdpi; float vdpi
if (SDL_GetDisplayDPI(_window_display_index, &ddpi, &hdpi, &vdpi)) { if (SDL_GetDisplayDPI(_window_display_index, &ddpi, &hdpi, &vdpi)) {
return ddpi; return ddpi
} }
//fallback //fallback
return 1; return 1
} }
int Renderer::get_window_size_w() const { int Renderer::get_window_size_w() const {
int w; int w
int h; int h
SDL_GetWindowSize(_window, &w, &h); SDL_GetWindowSize(_window, &w, &h)
return w; return w
} }
int Renderer::get_window_size_h() const { int Renderer::get_window_size_h() const {
int w; int w
int h; int h
SDL_GetWindowSize(_window, &w, &h); SDL_GetWindowSize(_window, &w, &h)
return h; return h
} }
int Renderer::get_size_w() const { int Renderer::get_size_w() const {
int w; int w
int h; int h
SDL_RenderGetLogicalSize(_renderer, &w, &h); SDL_RenderGetLogicalSize(_renderer, &w, &h)
return w; return w
} }
int Renderer::get_size_h() const { int Renderer::get_size_h() const {
int w; int w
int h; int h
SDL_RenderGetLogicalSize(_renderer, &w, &h); SDL_RenderGetLogicalSize(_renderer, &w, &h)
return h; return h
} }
void Renderer::get_size(int *w, int *h) const { void Renderer::get_size(int *w, int *h) const {
SDL_RenderGetLogicalSize(_renderer, w, h); SDL_RenderGetLogicalSize(_renderer, w, h)
} }
void Renderer::set_size(const int w, const int h) const { void Renderer::set_size(const int w, const int h) const {
SDL_RenderSetLogicalSize(_renderer, w, h); SDL_RenderSetLogicalSize(_renderer, w, h)
} }
float Renderer::get_scale_w() const { float Renderer::get_scale_w() const {
float w; float w
float h; float h
SDL_RenderGetScale(_renderer, &w, &h); SDL_RenderGetScale(_renderer, &w, &h)
return w; return w
} }
float Renderer::get_scale_h() const { float Renderer::get_scale_h() const {
float w; float w
float h; float h
SDL_RenderGetScale(_renderer, &w, &h); SDL_RenderGetScale(_renderer, &w, &h)
return h; return h
} }
void Renderer::set_scale(const float w, const float h) const { void Renderer::set_scale(const float w, const float h) const {
SDL_RenderSetScale(_renderer, w, h); SDL_RenderSetScale(_renderer, w, h)
} }
void Renderer::get_scale(float *w, float *h) const { void Renderer::get_scale(float *w, float *h) const {
SDL_RenderGetScale(_renderer, w, h); SDL_RenderGetScale(_renderer, w, h)
} }
bool Renderer::get_integer_scaling() const { bool Renderer::get_integer_scaling() const {
return SDL_RenderGetIntegerScale(_renderer); return SDL_RenderGetIntegerScale(_renderer)
} }
void Renderer::set_integer_scaling(const bool enable) { void Renderer::set_integer_scaling(const bool enable) {
if (enable) if (enable)
SDL_RenderSetIntegerScale(_renderer, SDL_TRUE); SDL_RenderSetIntegerScale(_renderer, SDL_TRUE)
else else
SDL_RenderSetIntegerScale(_renderer, SDL_FALSE); SDL_RenderSetIntegerScale(_renderer, SDL_FALSE)
} }
Rect2 Renderer::get_viewport() const { Rect2 Renderer::get_viewport() const {
SDL_Rect r; SDL_Rect r
SDL_RenderGetViewport(_renderer, &r); SDL_RenderGetViewport(_renderer, &r)
return Rect2(r.x, r.y, r.w, r.h); return Rect2(r.x, r.y, r.w, r.h)
} }
void Renderer::set_viewport(const Rect2 &rect) const { void Renderer::set_viewport(const Rect2 &rect) const {
SDL_Rect r = rect.as_rect(); SDL_Rect r = rect.as_rect()
SDL_RenderSetViewport(_renderer, &r); SDL_RenderSetViewport(_renderer, &r)
} }
Rect2 Renderer::get_clip_rect() const { Rect2 Renderer::get_clip_rect() const {
SDL_Rect r; SDL_Rect r
SDL_RenderGetClipRect(_renderer, &r); SDL_RenderGetClipRect(_renderer, &r)
return Rect2(r.x, r.y, r.w, r.h); return Rect2(r.x, r.y, r.w, r.h)
} }
void Renderer::set_clip_rect(Rect2 *rect) const { void Renderer::set_clip_rect(Rect2 *rect) const {
if (rect) { if (rect) {
SDL_Rect r = rect->as_rect(); SDL_Rect r = rect->as_rect()
SDL_RenderSetClipRect(_renderer, &r); SDL_RenderSetClipRect(_renderer, &r)
} else { } else {
SDL_RenderSetClipRect(_renderer, nullptr); SDL_RenderSetClipRect(_renderer, nullptr)
} }
} }
bool Renderer::clip_rect_enabled() const { bool Renderer::clip_rect_enabled() const {
return SDL_RenderIsClipEnabled(_renderer); return SDL_RenderIsClipEnabled(_renderer)
} }
bool Renderer::render_target_supported() { bool Renderer::render_target_supported() {
return SDL_RenderTargetSupported(_renderer); return SDL_RenderTargetSupported(_renderer)
} }
SDL_Texture *Renderer::get_render_target() { SDL_Texture *Renderer::get_render_target() {
return SDL_GetRenderTarget(_renderer); return SDL_GetRenderTarget(_renderer)
} }
void Renderer::set_render_target(Texture *texture) { void Renderer::set_render_target(Texture *texture) {
if (texture) { if (texture) {
SDL_SetRenderTarget(_renderer, texture->get_texture()); SDL_SetRenderTarget(_renderer, texture->get_texture())
} else { } else {
SDL_SetRenderTarget(_renderer, nullptr); SDL_SetRenderTarget(_renderer, nullptr)
} }
} }
void Renderer::initialize() { void Renderer::initialize() {
if (SDL_Init(_flags) != 0) { if (SDL_Init(_flags) != 0) {
printf("SDL_Init() hiba!\n"); printf("SDL_Init() hiba!\n")
return; return
} }
if (SDL_CreateWindowAndRenderer(_initial_window_width, _initial_window_height, _window_flags, &_window, &_renderer) != 0) { if (SDL_CreateWindowAndRenderer(_initial_window_width, _initial_window_height, _window_flags, &_window, &_renderer) != 0) {
printf("SDL_CreateWindowAndRenderer() hiba!\n"); printf("SDL_CreateWindowAndRenderer() hiba!\n")
return; return
} }
_window_display_index = SDL_GetWindowDisplayIndex(_window); _window_display_index = SDL_GetWindowDisplayIndex(_window)
} }
void Renderer::destroy() { void Renderer::destroy() {
if (_window) if (_window)
SDL_DestroyWindow(_window); SDL_DestroyWindow(_window)
if (_renderer) if (_renderer)
SDL_DestroyRenderer(_renderer); SDL_DestroyRenderer(_renderer)
_window = nullptr; _window = nullptr
_renderer = nullptr; _renderer = nullptr
} }
SDL_Window *Renderer::get_window() { SDL_Window *Renderer::get_window() {
return _window; return _window
} }
SDL_Renderer *Renderer::get_renderer() { SDL_Renderer *Renderer::get_renderer() {
return _renderer; return _renderer
} }
Renderer::Renderer() { Renderer::Renderer() {
if (_singleton) { if (_singleton) {
printf("Renderer::Renderer(): _singleton is not null!\n"); printf("Renderer::Renderer(): _singleton is not null!\n")
} }
_initial_window_width = 640; _initial_window_width = 640
_initial_window_height = 480; _initial_window_height = 480
_singleton = this; _singleton = this
_flags = SDL_INIT_VIDEO | SDL_INIT_TIMER; _flags = SDL_INIT_VIDEO | SDL_INIT_TIMER
_window_flags = SDL_WINDOW_SHOWN; _window_flags = SDL_WINDOW_SHOWN
initialize(); initialize()
} }
Renderer::Renderer(unsigned int flags, unsigned int window_flags, int initial_window_width, int initial_window_height) { Renderer::Renderer(unsigned int flags, unsigned int window_flags, int initial_window_width, int initial_window_height) {
if (_singleton) { if (_singleton) {
printf("Renderer::Renderer(flags): _singleton is not null!\n"); printf("Renderer::Renderer(flags): _singleton is not null!\n")
} }
_initial_window_width = initial_window_width; _initial_window_width = initial_window_width
_initial_window_height = initial_window_height; _initial_window_height = initial_window_height
_singleton = this; _singleton = this
_flags = flags; _flags = flags
_window_flags = window_flags; _window_flags = window_flags
initialize(); initialize()
} }
Renderer::~Renderer() { Renderer::~Renderer() {
if (_singleton != this) { if (_singleton != this) {
printf("Renderer::~Renderer(): _singleton is not this!\n"); printf("Renderer::~Renderer(): _singleton is not this!\n")
} }
_singleton = nullptr; _singleton = nullptr
destroy(); destroy()
} }
Renderer *Renderer::get_singleton() { Renderer *Renderer::get_singleton() {
return _singleton; return _singleton
} }
Renderer *Renderer::_singleton = nullptr; Renderer *Renderer::_singleton = nullptr