Relintai/sfw
1
0
Fork 0
mirror of https://github.com/Relintai/sfw.git synced 2024-12-20 21:06:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

Immediate renderer api setup.

Browse Source
This commit is contained in:
Relintai 2024-01-04 18:41:16 +01:00
parent 29a7478e0a
commit 49d055a9e0
2 changed files with 77 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

375
sfw/render_immediate/renderer.cpp
View File

@ -1,369 +1,72 @@
#include "renderer.h" #include "renderer.h"
#include <cstdio> #include "render_core/font.h"
#include "render_core/material.h"
#include "render_core/mesh.h"
#include "render_core/text_material.h"
#include "render_core/texture.h"
#include "render_core/window.h"
#include "render_core/font_material.h"
#include "render_core/font.h"
#include "core/math.h" #include "render_core/render_state.h"
void Renderer::present() { void Renderer::draw_point(const Vector2 &p_position, const Color &p_color = Color(1, 1, 1)) {
SDL_RenderPresent(_renderer); //Ugly but oh well
draw_rect(Rect2(p_position, Vector2(1, 1)), p_color);
}
void Renderer::draw_line(const Vector2 &p_from, const Vector2 &p_to, const Color &p_color = Color(1, 1, 1), const real_t p_width = 1) {
}
void Renderer::draw_line_rect(const Rect2 &p_rect, const Color &p_color = Color(1, 1, 1)) {
}
void Renderer::draw_rect(const Rect2 &p_rect, const Color &p_color = Color(1, 1, 1)) {
} }
void Renderer::set_draw_color(const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a) { void Renderer::draw_texture(const Ref<Texture> &p_texture, const Rect2 &dst_rect, const Color &p_modulate = Color(1, 1, 1)) {
SDL_SetRenderDrawColor(_renderer, r, g, b, a); }
void Renderer::draw_texture_clipped(const Ref<Texture> &p_texture, const Rect2 &p_src_rect, const Rect2 &p_dst_rect, const Color &p_modulate = Color(1, 1, 1)) {
} }
void Renderer::set_draw_color(const Color &color) { void Renderer::draw_mesh_2d(const Ref<Mesh> &p_mesh, const Ref<Material> &p_material, const Transform2D &p_transform_2d) {
SDL_SetRenderDrawColor(_renderer, color.r, color.g, color.b, color.a); }
void Renderer::draw_mesh_3d(const Ref<Mesh> &p_mesh, const Ref<Material> &p_material, const Transform &p_transform) {
} }
void Renderer::clear() { void Renderer::draw_text_2d(const Ref<Font> &p_mesh, const Vector2 &p_position, const Color &p_color = Color(1, 1, 1)) {
SDL_RenderClear(_renderer); }
void Renderer::draw_text_2d_tf(const Ref<Font> &p_mesh, const Transform2D &p_transform_2d, const Color &p_color = Color(1, 1, 1)) {
}
void Renderer::draw_text_2d_tf_material(const Ref<Font> &p_mesh, const Ref<Material> &p_material, const Transform2D &p_transform_2d) {
} }
SDL_BlendMode Renderer::get_blend_mode() const { Vector2i Renderer::get_window_size() const {
SDL_BlendMode mode; return Vector2i(AppWindow::get_singleton()->get_width(), AppWindow::get_singleton()->get_height())
SDL_GetRenderDrawBlendMode(_renderer, &mode);
return mode;
}
void Renderer::set_blend_mode(const SDL_BlendMode mode) {
SDL_SetRenderDrawBlendMode(_renderer, mode);
} }
void Renderer::draw_point(const int x, const int y) { float Renderer::get_window_aspect() const {
SDL_RenderDrawPoint(_renderer, x, y); return AppWindow::get_singleton()->get_aspect();
}
void Renderer::draw_point(const float x, const float y) {
SDL_RenderDrawPointF(_renderer, x, y);
}
void Renderer::draw_line(const int x1, const int x2, const int y1, const int y2) {
SDL_RenderDrawLine(_renderer, x1, x2, y1, y2);
}
void Renderer::draw_line(const float x1, const float x2, const float y1, const float y2) {
SDL_RenderDrawLineF(_renderer, x1, x2, y1, y2);
}
void Renderer::draw_rect(const Rect2 &rect) {
SDL_Rect r = rect.as_rect();
SDL_RenderDrawRect(_renderer, &r);
}
void Renderer::draw_fill_rect(const Rect2 &rect) {
SDL_Rect r = rect.as_rect();
SDL_RenderFillRect(_renderer, &r);
}
void Renderer::draw_texture(const Texture &texture, const Rect2 &dst_rect) {
SDL_Rect sr;
sr.x = 0;
sr.y = 0;
sr.w = texture.get_width();
sr.h = texture.get_height();
SDL_Rect dr = dst_rect.as_rect();
SDL_RenderCopy(_renderer, texture.get_texture(), &sr, &dr);
}
void Renderer::draw_texture(const Texture &texture, const Rect2 &src_rect, const Rect2 &dst_rect) {
SDL_Rect sr = src_rect.as_rect();
SDL_Rect dr = dst_rect.as_rect();
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) {
SDL_Rect sr = src_rect.as_rect();
SDL_FRect dr = dst_rect.as_frect();
SDL_FPoint p;
p.x = cx;
p.y = cy;
SDL_RenderCopyExF(_renderer, texture.get_texture(), &sr, &dr, angle, &p, flip);
}
void Renderer::draw_sprite(const Sprite &sprite) {
Texture *t = sprite.get_texture();
if (!t) {
return;
}
t->set_color_mod(sprite.get_color_mod());
double angle = sprite.get_angle();
if (Math::is_zero_approx(angle)) {
SDL_Rect sr = sprite.get_texture_clip_rect().as_rect();
SDL_Rect dr = sprite.get_transform().as_rect();
SDL_RenderCopy(_renderer, t->get_texture(), &sr, &dr);
} else {
SDL_Rect sr = sprite.get_texture_clip_rect().as_rect();
SDL_FRect dr = sprite.get_transform().as_frect();
SDL_FPoint p;
p.x = sprite.get_anchor_x();
p.y = sprite.get_anchor_y();
SDL_RenderCopyExF(_renderer, t->get_texture(), &sr, &dr, angle, &p, sprite.get_flip());
}
}
void Renderer::draw_sprite(const Sprite *sprite) {
if (!sprite)
return;
Texture *t = sprite->get_texture();
if (!t) {
return;
}
t->set_color_mod(sprite->get_color_mod());
double angle = sprite->get_angle();
if (Math::is_zero_approx(angle)) {
SDL_Rect sr = sprite->get_texture_clip_rect().as_rect();
SDL_Rect dr = sprite->get_transform().as_rect();
SDL_RenderCopy(_renderer, t->get_texture(), &sr, &dr);
} else {
SDL_Rect sr = sprite->get_texture_clip_rect().as_rect();
SDL_FRect dr = sprite->get_transform().as_frect();
SDL_FPoint p;
p.x = sprite->get_anchor_x();
p.y = sprite->get_anchor_y();
SDL_RenderCopyExF(_renderer, t->get_texture(), &sr, &dr, angle, &p, sprite->get_flip());
}
}
int Renderer::get_dpi() const {
float ddpi;
float hdpi;
float vdpi;
if (SDL_GetDisplayDPI(_window_display_index, &ddpi, &hdpi, &vdpi)) {
return ddpi;
}
//fallback
return 1;
}
int Renderer::get_window_size_w() const {
int w;
int h;
SDL_GetWindowSize(_window, &w, &h);
return w;
}
int Renderer::get_window_size_h() const {
int w;
int h;
SDL_GetWindowSize(_window, &w, &h);
return h;
}
int Renderer::get_size_w() const {
int w;
int h;
SDL_RenderGetLogicalSize(_renderer, &w, &h);
return w;
}
int Renderer::get_size_h() const {
int w;
int h;
SDL_RenderGetLogicalSize(_renderer, &w, &h);
return h;
}
void Renderer::get_size(int *w, int *h) const {
SDL_RenderGetLogicalSize(_renderer, w, h);
}
void Renderer::set_size(const int w, const int h) const {
SDL_RenderSetLogicalSize(_renderer, w, h);
}
float Renderer::get_scale_w() const {
float w;
float h;
SDL_RenderGetScale(_renderer, &w, &h);
return w;
}
float Renderer::get_scale_h() const {
float w;
float h;
SDL_RenderGetScale(_renderer, &w, &h);
return h;
}
void Renderer::set_scale(const float w, const float h) const {
SDL_RenderSetScale(_renderer, w, h);
}
void Renderer::get_scale(float *w, float *h) const {
SDL_RenderGetScale(_renderer, w, h);
}
bool Renderer::get_integer_scaling() const {
return SDL_RenderGetIntegerScale(_renderer);
}
void Renderer::set_integer_scaling(const bool enable) {
if (enable)
SDL_RenderSetIntegerScale(_renderer, SDL_TRUE);
else
SDL_RenderSetIntegerScale(_renderer, SDL_FALSE);
}
Rect2 Renderer::get_viewport() const {
SDL_Rect r;
SDL_RenderGetViewport(_renderer, &r);
return Rect2(r.x, r.y, r.w, r.h);
}
void Renderer::set_viewport(const Rect2 &rect) const {
SDL_Rect r = rect.as_rect();
SDL_RenderSetViewport(_renderer, &r);
}
Rect2 Renderer::get_clip_rect() const {
SDL_Rect r;
SDL_RenderGetClipRect(_renderer, &r);
return Rect2(r.x, r.y, r.w, r.h);
}
void Renderer::set_clip_rect(Rect2 *rect) const {
if (rect) {
SDL_Rect r = rect->as_rect();
SDL_RenderSetClipRect(_renderer, &r);
} else {
SDL_RenderSetClipRect(_renderer, nullptr);
}
}
bool Renderer::clip_rect_enabled() const {
return SDL_RenderIsClipEnabled(_renderer);
}
bool Renderer::render_target_supported() {
return SDL_RenderTargetSupported(_renderer);
}
SDL_Texture *Renderer::get_render_target() {
return SDL_GetRenderTarget(_renderer);
}
void Renderer::set_render_target(Texture *texture) {
if (texture) {
SDL_SetRenderTarget(_renderer, texture->get_texture());
} else {
SDL_SetRenderTarget(_renderer, nullptr);
}
} }
void Renderer::initialize() { void Renderer::initialize() {
if (SDL_Init(_flags) != 0) { ERR_FAIL_COND(_singleton);
printf("SDL_Init() hiba!\n");
return; memnew(Renderer);
}
if (SDL_CreateWindowAndRenderer(_initial_window_width, _initial_window_height, _window_flags, &_window, &_renderer) != 0) {
printf("SDL_CreateWindowAndRenderer() hiba!\n");
return;
}
_window_display_index = SDL_GetWindowDisplayIndex(_window);
} }
void Renderer::destroy() { void Renderer::destroy() {
if (_window) ERR_FAIL_COND(!_singleton);
SDL_DestroyWindow(_window);
if (_renderer) memdelete(_singleton);
SDL_DestroyRenderer(_renderer);
_window = nullptr;
_renderer = nullptr;
}
SDL_Window *Renderer::get_window() {
return _window;
}
SDL_Renderer *Renderer::get_renderer() {
return _renderer;
} }
Renderer::Renderer() { Renderer::Renderer() {
if (_singleton) {
printf("Renderer::Renderer(): _singleton is not null!\n");
}
_initial_window_width = 640;
_initial_window_height = 480;
_singleton = this; _singleton = this;
_flags = SDL_INIT_VIDEO | SDL_INIT_TIMER;
_window_flags = SDL_WINDOW_SHOWN;
initialize();
} }
Renderer::Renderer(unsigned int flags, unsigned int window_flags, int initial_window_width, int initial_window_height) {
if (_singleton) {
printf("Renderer::Renderer(flags): _singleton is not null!\n");
}
_initial_window_width = initial_window_width;
_initial_window_height = initial_window_height;
_singleton = this;
_flags = flags;
_window_flags = window_flags;
initialize();
}
Renderer::~Renderer() { Renderer::~Renderer() {
if (_singleton != this) { _singleton = NULL;
printf("Renderer::~Renderer(): _singleton is not this!\n");
}
_singleton = nullptr;
destroy();
} }
Renderer *Renderer::get_singleton() { Renderer *Renderer::get_singleton() {
return _singleton; return _singleton;
} }
Renderer *Renderer::_singleton = nullptr; Renderer *Renderer::_singleton = NULL;

108
sfw/render_immediate/renderer.h
View File

@ -3,91 +3,59 @@
#include "core/color.h" #include "core/color.h"
#include "core/rect2.h" #include "core/rect2.h"
#include "render_objects/sprite.h" #include "core/transform.h"
#include "render_core/texture.h" #include "core/transform_2d.h"
#include "core/rect2.h"
#include "core/vector2i.h"
#include <SDL.h> #include "object/object.h"
#include "object/reference.h"
class Mesh;
class Material;
class Texture;
class Font;
class FontMaterial;
class TextureMaterial2D;
class Renderer : public Object {
SFW_OBJECT(Renderer, Object);
class Renderer {
public: public:
void present(); void draw_point(const Vector2 &p_position, const Color &p_color = Color(1, 1, 1));
void set_draw_color(const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a); void draw_line(const Vector2 &p_from, const Vector2 &p_to, const Color &p_color = Color(1, 1, 1), const real_t p_width = 1);
void set_draw_color(const Color &color); void draw_line_rect(const Rect2 &p_rect, const Color &p_color = Color(1, 1, 1));
void clear(); void draw_rect(const Rect2 &p_rect, const Color &p_color = Color(1, 1, 1));
SDL_BlendMode get_blend_mode() const; void draw_texture(const Ref<Texture> &p_texture, const Rect2 &dst_rect, const Color &p_modulate = Color(1, 1, 1));
void set_blend_mode(const SDL_BlendMode mode); void draw_texture_clipped(const Ref<Texture> &p_texture, const Rect2 &p_src_rect, const Rect2 &p_dst_rect, const Color &p_modulate = Color(1, 1, 1));
void draw_point(const int x, const int y); void draw_mesh_2d(const Ref<Mesh> &p_mesh, const Ref<Material> &p_material, const Transform2D &p_transform_2d);
void draw_point(const float x, const float y); void draw_mesh_3d(const Ref<Mesh> &p_mesh, const Ref<Material> &p_material, const Transform &p_transform);
void draw_line(const int x1, const int x2, const int y1, const int y2); void draw_text_2d(const Ref<Font> &p_mesh, const Vector2 &p_position, const Color &p_color = Color(1, 1, 1));
void draw_line(const float x1, const float x2, const float y1, const float y2); void draw_text_2d_tf(const Ref<Font> &p_mesh, const Transform2D &p_transform_2d, const Color &p_color = Color(1, 1, 1));
void draw_text_2d_tf_material(const Ref<Font> &p_mesh, const Ref<Material> &p_material, const Transform2D &p_transform_2d);
void draw_rect(const Rect2 &rect); Vector2i get_window_size() const;
float get_window_aspect() const;
void draw_fill_rect(const Rect2 &rect); static void initialize();
static void destroy();
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 &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_sprite(const Sprite &sprite);
void draw_sprite(const Sprite *sprite);
int get_dpi() const;
int get_window_size_w() const;
int get_window_size_h() const;
int get_size_w() const;
int get_size_h() const;
void set_size(const int w, const int h) const;
void get_size(int *w, int *h) const;
float get_scale_w() const;
float get_scale_h() const;
void set_scale(const float w, const float h) const;
void get_scale(float *w, float *h) const;
bool get_integer_scaling() const;
void set_integer_scaling(const bool enable);
Rect2 get_viewport() const;
void set_viewport(const Rect2 &rect) const;
Rect2 get_clip_rect() const;
void set_clip_rect(Rect2 *rect) const;
bool clip_rect_enabled() const;
bool render_target_supported();
SDL_Texture *get_render_target();
void set_render_target(Texture *texture);
void initialize();
void destroy();
SDL_Window *get_window();
SDL_Renderer *get_renderer();
Renderer(); Renderer();
Renderer(unsigned int flags, unsigned int window_flags, int window_width = 640, int window_height = 480); ~Renderer();
virtual ~Renderer();
static Renderer *get_singleton(); static Renderer *get_singleton();
private: private:
int _initial_window_width;
int _initial_window_height;
unsigned int _flags;
unsigned int _window_flags;
SDL_Window *_window;
SDL_Renderer *_renderer;
int _window_display_index;
static Renderer *_singleton; static Renderer *_singleton;
Ref<Mesh> _2d_mesh;
Ref<Mesh> _3d_mesh;
Ref<TextureMaterial2D> _texture_material_2d;
Ref<FontMaterial> _font_material;
}; };
#endif #endif