red_bird 0.1.1

data/ext/red_bird/render.h

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_RENDER_H
+#define RED_BIRD_RENDER_H 1
+
+#include "main.h"
+
+extern VALUE bird_mRender;
+
+VALUE
+bird_mRender_set_color(VALUE self, VALUE color);
+
+VALUE
+bird_mRender_fill_rect(VALUE self, VALUE x, VALUE y,
+                       VALUE width, VALUE height);
+
+VALUE
+bird_mRender_clear_screen(VALUE self);
+
+VALUE
+bird_mRender_update_screen(VALUE self);
+
+void
+Init_red_bird_render(void);
+
+#endif /* RED_BIRD_RENDER_H */

data/ext/red_bird/sprite.c

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: MIT
+#include "sprite.h"
+
+#include "engine.h"
+#include "texture.h"
+
+VALUE bird_cSprite;
+
+static ID id_at_texture;
+
+/*
+  Basic functions that all Ruby classes need.
+ */
+
+void
+bird_free_sprite(void* obj)
+{
+  struct bird_sprite_data *ptr = obj;
+
+  free(ptr);
+}
+
+size_t
+bird_memsize_sprite(const void* obj)
+{
+  // TODO
+  return 0;
+}
+
+static const rb_data_type_t
+bird_sprite_type = {
+  "red_bird_sprite",
+  {0, bird_free_sprite, bird_memsize_sprite,},
+  0, 0,
+  RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE
+bird_alloc_sprite(VALUE klass)
+{
+  VALUE obj;
+  struct bird_sprite_data *ptr;
+
+  obj = TypedData_Make_Struct(klass, struct bird_sprite_data,
+                              &bird_sprite_type, ptr);
+
+  return obj;
+}
+
+/*
+  @param texture [RedBird::Texture] image to use as source for this sprite.
+  @param x [Integer] vertical position in the texture.
+  @param y [Integer] horizontal position in the texture.
+  @param width [Integer] width of the sprite.
+  @param height [Integer] height of the sprite.
+  @return [RedBird::Sprite] self
+  @author Frederico Linhares
+*/
+VALUE
+bird_cSprite_initialize(VALUE self, VALUE texture, VALUE  x, VALUE  y,
+                        VALUE  width, VALUE  height)
+{
+  struct bird_sprite_data *ptr;
+
+  if(!rb_obj_is_kind_of(texture, bird_cTexture))
+    rb_raise(rb_eTypeError, "%s",
+             "texture must be an instance of RedBird::Texture");
+  RB_INTEGER_TYPE_P(x);
+  RB_INTEGER_TYPE_P(y);
+  RB_INTEGER_TYPE_P(width);
+  RB_INTEGER_TYPE_P(height);
+
+  TypedData_Get_Struct(self, struct bird_sprite_data, &bird_sprite_type, ptr);
+
+  rb_ivar_set(self, id_at_texture, texture);
+  ptr->rect.x = NUM2INT(x);
+  ptr->rect.y = NUM2INT(y);
+  ptr->rect.w = NUM2INT(width);
+  ptr->rect.h = NUM2INT(height);
+
+  return self;
+}
+
+/*
+  Render this sprite to the screen.
+
+  @param x [Integer] screen horizontal position.
+  @param y [Integer] screen vertical position.
+  @return [RedBird::Sprite] self
+  @author Frederico Linhares
+*/
+VALUE
+bird_cSprite_render_to_screen(VALUE self, VALUE  x, VALUE  y)
+{
+  SDL_Rect dst_rect;
+
+  struct bird_sprite_data *ptr;
+  struct bird_texture_data *texture_ptr;
+
+  VALUE texture;
+
+  RB_INTEGER_TYPE_P(x);
+  RB_INTEGER_TYPE_P(y);
+
+  texture = rb_ivar_get(self, id_at_texture);
+
+  TypedData_Get_Struct(self, struct bird_sprite_data, &bird_sprite_type, ptr);
+  texture_ptr = bird_cTexture_get_data(texture);
+
+  dst_rect.x = NUM2INT(x);
+  dst_rect.y = NUM2INT(y);
+  dst_rect.w = ptr->rect.w;
+  dst_rect.h = ptr->rect.h;
+
+  SDL_RenderCopy(bird_core.renderer, texture_ptr->data, &ptr->rect,
+                 &dst_rect);
+
+  return self;
+}
+
+void
+Init_red_bird_sprite(void)
+{
+  id_at_texture = rb_intern("@texture");
+  bird_cSprite = rb_define_class_under(bird_m, "Sprite", rb_cData);
+  rb_define_alloc_func(bird_cSprite, bird_alloc_sprite);
+  rb_define_method(bird_cSprite, "initialize", bird_cSprite_initialize, 5);
+  rb_define_method(bird_cSprite, "render_to_screen",
+                   bird_cSprite_render_to_screen, 2);
+}

data/ext/red_bird/sprite.h

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_SPRITE_H
+#define RED_BIRD_SPRITE_H 1
+
+#include "main.h"
+
+extern VALUE bird_cSprite;
+
+struct bird_sprite_data
+{
+  SDL_Rect rect;
+};
+
+VALUE
+bird_alloc_sprite(VALUE klass);
+
+VALUE
+bird_cSprite_initialize(VALUE self, VALUE texture, VALUE  x, VALUE  y,
+                        VALUE  width, VALUE  height);
+
+VALUE
+bird_cSprite_render_to_screen(VALUE self, VALUE  x, VALUE  y);
+
+void
+Init_red_bird_sprite(void);
+
+#endif // RED_BIRD_SPRITE_H

data/ext/red_bird/text.c

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: MIT
+#include "text.h"
+
+#include "color.h"
+#include "engine.h"
+#include "font.h"
+
+/*
+  Document-class: RedBird::Text
+
+  A text to be printed on the screen. This class renders the text received
+  during the initialization as an image and store the image internally for
+  rendering.
+
+  @author Frederico Linhares
+*/
+VALUE bird_cText;
+
+/*
+  Basic functions all Ruby classes need.
+*/
+
+static void
+bird_free_text(void* obj)
+{
+  struct bird_text_data *ptr = obj;
+
+  SDL_DestroyTexture(ptr->data);
+  free(ptr);
+}
+
+static size_t
+bird_memsize_text(const void* obj)
+{
+  // TODO
+  return 0;
+}
+
+static const rb_data_type_t
+bird_text_type = {
+  "red_bird_text",
+  {0, bird_free_text, bird_memsize_text,},
+  0, 0,
+  RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+bird_alloc_text(VALUE klass)
+{
+  VALUE obj;
+  struct bird_text_data *ptr;
+
+  obj = TypedData_Make_Struct(klass, struct bird_text_data, &bird_text_type,
+                              ptr);
+
+  return obj;
+}
+
+/*
+  @param text [String] text to rendered.
+  @param font [RedBird::Font] font to be used for rendering the text.
+  @param tx_color [RedBird::Color] text color.
+  @param bg_color [RedBird::Color, nil] if the attribute is a color, this color
+    will be used as background; if the attribute is nil, there will be no
+    background.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cText_initialize(VALUE self, VALUE text, VALUE font, VALUE tx_color,
+                      VALUE bg_color)
+{
+  SDL_Surface *surface = NULL;
+
+  struct bird_text_data *ptr;
+  struct bird_font_data *font_ptr;
+  struct bird_color_data *tx_color_ptr;
+  struct bird_color_data *bg_color_ptr;
+
+  if(!engine_initialized)
+    rb_raise(rb_eRuntimeError, "%s",
+             "can not create a RedBird::Text instance before RedBird::Engine "
+             "is started");
+
+  SafeStringValue(text);
+
+  if(!rb_obj_is_kind_of(font, bird_cFont))
+  {
+    rb_raise(rb_eTypeError, "%s", "font must be an instance of RedBird::Font");
+    return self;
+  }
+
+  if(!rb_obj_is_kind_of(tx_color, bird_cColor))
+  {
+    rb_raise(rb_eTypeError, "%s",
+             "tx_color must be an instance of RedBird::Color");
+    return self;
+  }
+
+  font_ptr = bird_cFont_get_data(font);
+  tx_color_ptr = bird_cColor_get_data(tx_color);
+  if(TYPE(bg_color) == T_NIL)
+  {
+    surface = TTF_RenderUTF8_Solid(font_ptr->data, StringValueCStr(text),
+                                   tx_color_ptr->data);
+  }
+  else if(rb_obj_is_kind_of(bg_color, bird_cColor))
+  {
+    bg_color_ptr = bird_cColor_get_data(bg_color);
+    surface = TTF_RenderUTF8_Shaded(font_ptr->data, StringValueCStr(text),
+                                    tx_color_ptr->data, bg_color_ptr->data);
+  }
+  else
+  {
+    rb_raise(rb_eTypeError, "%s",
+             "bg_color must be an instance of RedBird::Color or nil");
+    return self;
+  }
+
+  if(surface == NULL)
+  {
+    rb_raise(rb_eRuntimeError, "failed to render text: %s", TTF_GetError());
+    return self;
+  }
+
+  TypedData_Get_Struct(self, struct bird_text_data, &bird_text_type, ptr);
+
+  ptr->data = NULL;
+  ptr->data = SDL_CreateTextureFromSurface(bird_core.renderer, surface);
+  SDL_FreeSurface(surface);
+  if(ptr->data == NULL)
+  {
+    rb_raise(rb_eRuntimeError, "failed to convert text: %s", SDL_GetError());
+    return self;
+  }
+
+  SDL_QueryTexture(ptr->data, NULL, NULL, &ptr->width, &ptr->height);
+  return self;
+}
+
+/*
+  Returns the width of the image.
+
+  @return [Integer] text width.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cText_width(VALUE self)
+{
+  struct bird_text_data *ptr;
+
+  TypedData_Get_Struct(self, struct bird_text_data, &bird_text_type, ptr);
+
+  return INT2FIX(ptr->width);
+}
+
+/*
+  Returns the height of the image.
+
+  @return [Integer] text height.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cText_height(VALUE self)
+{
+  struct bird_text_data *ptr;
+
+  TypedData_Get_Struct(self, struct bird_text_data, &bird_text_type, ptr);
+
+  return INT2FIX(ptr->height);
+}
+
+/*
+  Render this text to the screen.
+
+  @param x [Integer] screen horizontal position.
+  @param y [Integer] screen vertical position.
+  @return [RedBird::Sprite] self
+  @author Frederico Linhares
+*/
+VALUE
+bird_cText_render_to_screen(VALUE self, VALUE  x, VALUE  y)
+{
+  SDL_Rect dst_rect;
+
+  struct bird_text_data *ptr;
+
+  RB_INTEGER_TYPE_P(x);
+  RB_INTEGER_TYPE_P(y);
+
+  TypedData_Get_Struct(self, struct bird_text_data, &bird_text_type, ptr);
+
+  dst_rect.x = NUM2INT(x);
+  dst_rect.y = NUM2INT(y);
+  dst_rect.w = ptr->width;
+  dst_rect.h = ptr->height;
+
+  SDL_RenderCopy(bird_core.renderer, ptr->data, NULL, &dst_rect);
+
+  return self;
+}
+
+void
+Init_red_bird_text(void)
+{
+  bird_cText = rb_define_class_under(bird_m, "Text", rb_cData);
+  rb_define_alloc_func(bird_cText, bird_alloc_text);
+  rb_define_method(bird_cText, "initialize", bird_cText_initialize, 4);
+  rb_define_method(bird_cText, "width", bird_cText_width, 0);
+  rb_define_method(bird_cText, "height", bird_cText_height, 0);
+  rb_define_method(bird_cText, "render_to_screen",
+                   bird_cText_render_to_screen, 2);
+}

data/ext/red_bird/text.h

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+#ifndef RED_BIRD_TEXT_H
+#define RED_BIRD_TEXT_H 1
+
+#include "main.h"
+
+extern VALUE bird_cText;
+
+struct bird_text_data
+{
+  SDL_Texture* data;
+  int width, height;
+};
+
+VALUE
+bird_cText_initialize(VALUE self, VALUE text, VALUE font, VALUE tx_color,
+                      VALUE bg_color);
+
+VALUE
+bird_cText_width(VALUE self);
+
+VALUE
+bird_cText_height(VALUE self);
+
+VALUE
+bird_cText_render_to_screen(VALUE self, VALUE  x, VALUE  y);
+
+void
+Init_red_bird_text(void);
+
+#endif /* RED_BIRD_TEXT_H */

data/ext/red_bird/texture.c

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+#include "texture.h"
+#include "texture_imp.hpp"
+
+#include "engine.h"
+#include "palette.h"
+
+/*
+  Document-class: RedBird::Texture
+
+  An image optimized for rendering on the screen.
+
+  @author Frederico Linhares
+*/
+VALUE bird_cTexture;
+
+/*
+  Basic functions all Ruby classes need.
+ */
+
+void
+bird_free_texture(void* obj)
+{
+  struct bird_texture_data *ptr = obj;
+
+  SDL_DestroyTexture(ptr->data);
+  free(ptr);
+}
+
+size_t
+bird_memsize_texture(const void* obj)
+{
+  // TODO
+  return 0;
+}
+
+static const rb_data_type_t
+bird_texture_type = {
+  "red_bird_texture",
+  {0, bird_free_texture, bird_memsize_texture,},
+  0, 0,
+  RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE
+bird_alloc_texture(VALUE klass)
+{
+  VALUE obj;
+  struct bird_texture_data *ptr;
+
+  obj = TypedData_Make_Struct(klass, struct bird_texture_data,
+                              &bird_texture_type, ptr);
+
+  return obj;
+}
+
+/*
+  @param file_path [String] path to an image to be loaded into a texture.
+  @author Frederico Linhares
+*/
+VALUE
+bird_cTexture_initialize(VALUE self, VALUE file_path, VALUE palette)
+{
+  struct bird_texture_data *ptr;
+  struct bird_palette_data *palette_data;
+  struct bird_cTexture_PGM pgm_img;
+  SDL_Surface *surface = NULL;
+
+  if(!engine_initialized)
+    rb_raise(rb_eRuntimeError, "%s",
+             "can not create a RedBird::Texture instance before "
+             "RedBird::Engine is started");
+
+  if(!rb_obj_is_kind_of(palette, bird_cPalette))
+    rb_raise(
+        rb_eArgError, "%s",
+        "palette must be and instance of RedBird::Palette");
+
+  SafeStringValue(file_path);
+  if(!bird_cTexture_PGM_load(&pgm_img, StringValueCStr(file_path)))
+    rb_raise(
+        rb_eArgError, "%s",
+        "failed to load image: it does not exists or is in an invalid format");
+
+  // Depth = 8 bits image.
+  // Pitch = 1 byte (8 bits) * image width.
+  surface = SDL_CreateRGBSurfaceWithFormatFrom(
+      pgm_img.data, pgm_img.width, pgm_img.height, 8, pgm_img.width,
+      SDL_PIXELFORMAT_INDEX8);
+  bird_cTexture_PGM_unload(&pgm_img);
+  if(surface == NULL)
+    rb_raise(rb_eArgError, "failed to create surface: %s\n", SDL_GetError());
+
+  TypedData_Get_Struct(self, struct bird_texture_data, &bird_texture_type,
+                       ptr);
+  palette_data = bird_cPalette_get_data(palette);
+  SDL_SetPaletteColors(surface->format->palette, palette_data->colors, 0, 256);
+
+  ptr->data = SDL_CreateTextureFromSurface(bird_core.renderer, surface);
+  SDL_FreeSurface(surface);
+  if(ptr->data == NULL)
+    rb_raise(rb_eArgError, "failed to convert image: %s\n", SDL_GetError());
+
+  SDL_QueryTexture(ptr->data, NULL, NULL, &ptr->width, &ptr->height);
+  return self;
+}
+
+/*
+  @return [Integer]
+  @author Frederico Linhares
+*/
+VALUE
+bird_cTexture_width(VALUE self)
+{
+  struct bird_texture_data *ptr;
+
+  TypedData_Get_Struct(self, struct bird_texture_data, &bird_texture_type,
+                       ptr);
+
+  return INT2FIX(ptr->width);
+}
+
+/*
+  @return [Integer]
+  @author Frederico Linhares
+*/
+VALUE
+bird_cTexture_height(VALUE self)
+{
+  struct bird_texture_data *ptr;
+
+  TypedData_Get_Struct(self, struct bird_texture_data, &bird_texture_type,
+                       ptr);
+
+  return INT2FIX(ptr->height);
+}
+
+struct bird_texture_data*
+bird_cTexture_get_data(VALUE self)
+{
+  struct bird_texture_data *ptr;
+
+  TypedData_Get_Struct(self, struct bird_texture_data, &bird_texture_type,
+                       ptr);
+
+  return ptr;
+}
+
+void
+Init_red_bird_texture(void)
+{
+  bird_cTexture = rb_define_class_under(bird_m, "Texture", rb_cData);
+  rb_define_alloc_func(bird_cTexture, bird_alloc_texture);
+  rb_define_method(bird_cTexture, "initialize", bird_cTexture_initialize, 2);
+  rb_define_method(bird_cTexture, "width", bird_cTexture_width, 0);
+  rb_define_method(bird_cTexture, "height", bird_cTexture_height, 0);
+}