segment comparison operators; get sdl surface from pixels

demo/Demo.cpp

@@ -15,7 +15,8 @@
   node children list, node animations list, copy constructor for all base
   classes, private and public class members, pixel class iterator, sprite
   movement history, input history, use seconds instead of milliseconds, store
-  a node's animations in list
+  a node's animations in list, frame object for sprite class, inline short
+  functions
 
   :) SWEATY HANDS :) OILY SNACKS :) AND BAD HYGIENE :)
 

src/Pixels.hpp

@@ -29,7 +29,7 @@ struct Pixels
     ~Pixels();
 
     template <typename T = void*>
-    T operator()(int x, int y)
+    T operator()(int x = 0, int y = 0)
     {
         std::uint8_t* access = static_cast<std::uint8_t*>(source);
         if (x < 0 || x >= rect.w)

src/Segment.cpp

@@ -124,9 +124,35 @@ void Segment::move(const glm::vec2& delta)
     end += delta;
 }
 
-glm::vec2 Segment::get_center()
+glm::vec2 Segment::get_center() const
 {
-    return sfw::get_segments(*this, 2)[0].end;
+    return get_subsegments(2)[0].end;
+}
+
+glm::vec2 Segment::get_step(float speed) const
+{
+    float angle = glm::atan(end.x - start.x, end.y - start.y);
+    return glm::vec2(speed * glm::sin(angle), speed * glm::cos(angle));
+}
+
+glm::vec2 Segment::get_step_relative(float relative_length_per_step) const
+{
+    return get_step(glm::distance(start, end) * relative_length_per_step);
+}
+
+std::vector<Segment> Segment::get_subsegments(int count) const
+{
+    glm::vec2 step = get_step_relative(1.0f / count);
+    std::vector<Segment> subsegments;
+    subsegments.reserve(count);
+    glm::vec2 subsegment_start = start, subsegment_end;
+    for (int ii = 0; ii < count; ii++)
+    {
+        subsegment_end = subsegment_start + step;
+        subsegments.emplace_back(subsegment_start, subsegment_end);
+        subsegment_start = subsegment_end;
+    }
+    return subsegments;
 }
 
 std::ostream& operator<<(std::ostream& out, const Segment& segment)

src/Segment.hpp

@@ -22,14 +22,37 @@ struct Segment
     void set_start(const glm::vec2&);
     glm::vec2 get_end() const;
     void set_end(const glm::vec2&);
-    bool intersect(const Segment&, glm::vec2* = NULL) const;
+    bool intersect(const Segment&, glm::vec2* = nullptr) const;
     bool intersect(const Segment&, glm::vec2&) const;
     float get_dx() const;
     float get_dy() const;
     float get_length() const;
     Box get_box() const;
     void move(const glm::vec2&);
-    glm::vec2 get_center();
+    glm::vec2 get_center() const;
+    glm::vec2 get_step(float) const;
+    glm::vec2 get_step_relative(float) const;
+    std::vector<Segment> get_subsegments(int) const;
+    inline bool operator<(const Segment& segment) const { return operator<(segment.get_length()); }
+
+    /*
+      std::cout << (a < b) << (a > b) << (b < c) << (b <= c) << (c > b) << (c >= b) << (d < 1) << (d < 2) <<
+        (d >= a) << (d > c) << std::endl;
+
+      should print 0101010101
+    */
+
+    template<typename N>
+    inline bool operator<(const N& other) const { return get_length() < other; }
+
+    template<typename N>
+    inline bool operator>(const N& other) const { return other < get_length(); }
+
+    template<typename N>
+    inline bool operator<=(const N& other) const { return !operator>(other); }
+
+    template<typename N>
+    inline bool operator>=(const N& other) const { return !operator<(other); }
 
 };
 

src/Sprite.cpp

@@ -93,7 +93,7 @@ void Sprite::add_frames(SDL_Texture* frame)
     all_frames_frameset.clear();
     for (std::size_t ii = 0; ii < frames.size(); ii++)
     {
-        all_frames_frameset.add_frame_index(ii);
+        all_frames_frameset.add_frame_indicies(ii);
     }
     for (auto& [name, frameset] : framesets)
     {
@@ -782,14 +782,17 @@ Frameset::Frameset() : Frameset(NULL) {}
 
 Frameset::Frameset(Sprite* sprite) : sprite(sprite) {}
 
-void Frameset::add_frame_index(int index)
+void Frameset::add_frame_indicies(int index)
 {
-    add_frame_indicies({index});
+    order.push_back(index);
 }
 
 void Frameset::add_frame_indicies(const std::vector<int>& indicies)
 {
-    order.insert(order.end(), indicies.begin(), indicies.end());
+    for (const int& index : indicies)
+    {
+        add_frame_indicies(index);
+    }
 }
 
 void Frameset::set_frame_length(float length)

src/Sprite.hpp

@@ -147,7 +147,7 @@ struct Frameset
 
     Frameset();
     Frameset(Sprite*);
-    void add_frame_index(int);
+    void add_frame_indicies(int);
     void add_frame_indicies(const std::vector<int>&);
     void set_frame_length(float);
     float get_frame_length() const;

src/extension.cpp

@@ -1,32 +1,8 @@
+#include "sdl2-gfx/SDL2_gfxPrimitives.h"
+
+#include "Pixels.hpp"
 #include "extension.hpp"
 
-glm::vec2 sfw::get_step(const Segment& segment, float speed)
-{
-    float angle = glm::atan(segment.end.x - segment.start.x, segment.end.y - segment.start.y);
-    return glm::vec2(speed * glm::sin(angle), speed * glm::cos(angle));
-}
-
-glm::vec2 sfw::get_step_relative(const Segment& segment, float relative_length_per_step)
-{
-    return get_step(
-        segment, glm::distance(segment.start, segment.end) * relative_length_per_step);
-}
-
-std::vector<Segment> sfw::get_segments(const Segment& base, int count)
-{
-    glm::vec2 step = get_step_relative(base, 1.0f / count);
-    std::vector<Segment> segments;
-    segments.reserve(count);
-    glm::vec2 start = base.start, end;
-    for (int ii = 0; ii < count; ii++)
-    {
-        end = start + step;
-        segments.emplace_back(start, end);
-        start = end;
-    }
-    return segments;
-}
-
 void sfw::set_magnitude(glm::vec2& vector, float magnitude)
 {
     vector = glm::normalize(vector) * magnitude;
@@ -525,6 +501,23 @@ std::vector<fs::path> sfw::glob(fs::path query)
     return files;
 }
 
+SDL_Surface* sfw::get_surface_from_pixels(Pixels& pixels)
+{
+    SDL_Surface* surface = SDL_CreateRGBSurfaceFrom(
+        pixels.source, pixels.rect.w, pixels.rect.h, pixels.format->BitsPerPixel,
+        pixels.get_bytes_per_row(), pixels.format->Rmask, pixels.format->Gmask, pixels.format->Bmask,
+        pixels.format->Amask);
+    if (surface == nullptr)
+    {
+        print_sdl_error("could not create RGB surface from texture pixel data");
+    }
+    else
+    {
+        return surface;
+    }
+    return nullptr;
+}
+
 fs::path sfw::get_next_file_name(
     fs::path directory, int zfill, std::string prefix, std::string extension)
 {

src/extension.hpp

@@ -25,16 +25,13 @@
 #include "Color.hpp"
 #include "filesystem.hpp"
 
-struct Node;
+struct Pixels;
 
 namespace sfw
 {
 
     enum scaler {scale2x, xbr};
 
-    glm::vec2 get_step(const Segment&, float);
-    glm::vec2 get_step_relative(const Segment&, float);
-    std::vector<Segment> get_segments(const Segment&, int);
     void set_magnitude(glm::vec2&, float);
     Box get_texture_box(SDL_Texture*);
     std::vector<std::vector<Box>> get_blinds_boxes(glm::vec2, float = 0.05f, int = 4);
@@ -58,6 +55,7 @@ namespace sfw
     SDL_Texture* get_remapped_texture(SDL_Renderer*, SDL_Texture*, const std::map<Color, Color>&);
     SDL_Texture* get_remapped_texture(SDL_Renderer*, const std::string&, const std::map<Color, Color>&);
     SDL_Texture* get_pixel_scaled_texture(SDL_Renderer*, SDL_Texture*, int = 1, int = scaler::scale2x);
+    SDL_Surface* get_surface_from_pixels(Pixels&);
     std::vector<fs::path> glob(fs::path);
     fs::path get_next_file_name(
         fs::path, int = 0, std::string = "", std::string = "");
@@ -198,7 +196,4 @@ namespace glm
     }
 }
 
-#include "Node.hpp"
-#include "Pixels.hpp"
-
 #endif