204 lines
6.2 KiB
C++
204 lines
6.2 KiB
C++
#ifndef extension_h_
|
|
#define extension_h_
|
|
|
|
#include <vector>
|
|
#include <iostream>
|
|
#include <regex>
|
|
#include <sstream>
|
|
#include <algorithm>
|
|
#include <iomanip>
|
|
#include <stdexcept>
|
|
#include <map>
|
|
#include <cmath>
|
|
|
|
#include "SDL.h"
|
|
#include "SDL_image.h"
|
|
#include "SDL_pixels.h"
|
|
#define GLM_ENABLE_EXPERIMENTAL
|
|
#include "glm/trigonometric.hpp"
|
|
#include "glm/vec2.hpp"
|
|
#include "glm/gtx/vector_angle.hpp"
|
|
#include "json/json.hpp"
|
|
|
|
#include "Box.hpp"
|
|
#include "Segment.hpp"
|
|
#include "Color.hpp"
|
|
#include "filesystem.hpp"
|
|
|
|
struct Node;
|
|
|
|
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);
|
|
void populate_pixel_2d_array(SDL_Renderer*, SDL_Texture*, std::vector<std::vector<SDL_Color>>&);
|
|
void populate_pixel_2d_array(SDL_Renderer*, SDL_Texture*, std::vector<std::vector<SDL_Color>>&, const Box&);
|
|
void apply_array_to_texture(SDL_Renderer*, SDL_Texture*, std::vector<std::vector<SDL_Color>>&);
|
|
void apply_array_to_texture(SDL_Renderer*, SDL_Texture*, std::vector<std::vector<SDL_Color>>&, const Box&);
|
|
std::vector<SDL_Texture*> get_halo_frames(
|
|
Node&, float, int, const std::vector<SDL_Color>& = {{0, 0, 0, 255}, {255, 255, 255, 255}}, float = 4.0f, bool = true);
|
|
std::vector<SDL_Texture*> get_portal_frames(SDL_Renderer*, glm::vec2, float = 60, float = 30, int = 4, int = 6);
|
|
void fill_texture(SDL_Renderer*, SDL_Texture*, const SDL_Color&, const Box&);
|
|
void fill_texture(SDL_Renderer*, SDL_Texture*, const SDL_Color&);
|
|
void fill_texture(SDL_Renderer*, SDL_Texture*, SDL_Texture*, const Box&);
|
|
void fill_texture(SDL_Renderer*, SDL_Texture*, SDL_Texture*);
|
|
SDL_Texture* get_filled_texture(SDL_Renderer*, glm::vec2, const SDL_Color&, Uint32 = SDL_PIXELFORMAT_RGBA32);
|
|
SDL_Texture* get_filled_texture(SDL_Renderer*, glm::vec2, SDL_Texture*, Uint32 = SDL_PIXELFORMAT_RGBA32);
|
|
SDL_Texture* get_hue_shifted_texture(SDL_Renderer*, SDL_Texture*, float);
|
|
SDL_Texture* duplicate_texture(SDL_Renderer*, SDL_Texture*);
|
|
SDL_Texture* duplicate_texture(SDL_Renderer*, SDL_Texture*, const glm::vec2&);
|
|
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);
|
|
std::vector<fs::path> glob(fs::path);
|
|
fs::path get_next_file_name(
|
|
fs::path, int = 0, std::string = "", std::string = "");
|
|
void print_error(const std::string&);
|
|
void print_sdl_error(const std::string&);
|
|
|
|
template<typename Key, typename Value, template <typename...> class Map>
|
|
std::vector<Key> get_keys(const Map<Key, Value>& map)
|
|
{
|
|
std::vector<Key> keys;
|
|
keys.reserve(map.size());
|
|
for (auto& member : map)
|
|
{
|
|
keys.push_back(member.first);
|
|
}
|
|
return keys;
|
|
}
|
|
|
|
template<typename T1, typename T2>
|
|
bool is_in_container(T1& container, T2& member)
|
|
{
|
|
return std::find(container.begin(), container.end(), member) != container.end();
|
|
}
|
|
|
|
template<typename N>
|
|
inline float mod(N a, N b)
|
|
{
|
|
return (b + (a % b)) % b;
|
|
}
|
|
|
|
template<typename T>
|
|
std::string pad(T end, int width, char fill = '0')
|
|
{
|
|
std::stringstream padded;
|
|
padded.fill(fill);
|
|
padded.width(width);
|
|
padded << end;
|
|
return padded.str();
|
|
}
|
|
|
|
template <typename N, typename N2 = N>
|
|
std::vector<N2> range(N start, N stop, N2 step)
|
|
{
|
|
if (step == N2(0))
|
|
{
|
|
throw std::invalid_argument("step for range must be non-zero");
|
|
}
|
|
std::vector<N2> result;
|
|
while ((step > 0) ? (start < stop) : (start > stop))
|
|
{
|
|
result.push_back(start);
|
|
start += step;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
template <typename N>
|
|
std::vector<N> range(N start, N stop)
|
|
{
|
|
return range(start, stop, N(1));
|
|
}
|
|
|
|
template <typename N>
|
|
std::vector<N> range(N stop)
|
|
{
|
|
return range(N(0), stop, N(1));
|
|
}
|
|
|
|
template <typename N>
|
|
std::vector<float> range_count(N start, N end, int count)
|
|
{
|
|
float step = (end - start) / (count - 1);
|
|
std::vector<float> all;
|
|
all.reserve(count);
|
|
for (int ii = 0; ii < count; ii++)
|
|
{
|
|
all.push_back(start + ii * step);
|
|
}
|
|
return all;
|
|
}
|
|
|
|
template <typename N, typename N2 = N>
|
|
std::map<float, N2> range_percent(N start, N end, N2 step = N(1))
|
|
{
|
|
std::map<float, N2> range_percent_map;
|
|
std::vector<N2> all = range(start, end, step);
|
|
int ii = 0;
|
|
for (N2& current : all)
|
|
{
|
|
range_percent_map[ii++ / static_cast<float>(all.size() - 1)] = current;
|
|
}
|
|
return range_percent_map;
|
|
}
|
|
|
|
template <typename N>
|
|
std::map<float, float> range_percent_count(N start, N end, int count)
|
|
{
|
|
std::map<float, float> range_percent_map;
|
|
std::vector<float> all = range_count(start, end, count);
|
|
int ii = 0;
|
|
for (float& current : all)
|
|
{
|
|
range_percent_map[ii++ / static_cast<float>(all.size() - 1)] = current;
|
|
}
|
|
return range_percent_map;
|
|
}
|
|
|
|
}
|
|
|
|
template <typename T>
|
|
std::ostream& operator<<(std::ostream& out, const std::vector<T>& members)
|
|
{
|
|
out << "{ ";
|
|
for (const T& member : members)
|
|
{
|
|
out << member << " ";
|
|
}
|
|
out << "}";
|
|
return out;
|
|
}
|
|
|
|
std::ostream& operator<<(std::ostream&, const glm::vec2&);
|
|
std::ostream& operator<<(std::ostream&, const SDL_Color&);
|
|
|
|
namespace glm
|
|
{
|
|
template <typename T>
|
|
void to_json(nlohmann::json& j, const vec<2, T, defaultp>& v)
|
|
{
|
|
j = nlohmann::json{{"x", v.x}, {"y", v.y}};
|
|
}
|
|
|
|
template <typename T>
|
|
void from_json(const nlohmann::json& j, vec<2, T, defaultp>& v)
|
|
{
|
|
j.at(0).get_to(v.x);
|
|
j.at(1).get_to(v.y);
|
|
}
|
|
}
|
|
|
|
#include "Node.hpp"
|
|
#include "Pixels.hpp"
|
|
|
|
#endif
|