shampoo/spacebox
shampoo
/
spacebox
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

box inherits sdl_rect; color comparison operators; pixels operator() returns pointer of void, 8bit, 16bit, or 32bit; remap texture uses pixel class

This commit is contained in:
Frank DeMarco 2020-08-26 16:43:43 -04:00
parent 8346f43f21
commit edc836908d
11 changed files with 232 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
demo/Demo.cpp
View File

@ -13,7 +13,7 @@
resolution, debug display, loading wheel animation, shadowed sprite, separate
update and draw, sprite movement cage, multiple windows, multiple renderers,
node children list, node animations list, copy constructor for node, private
and public class members
and public class members, pixel class iterator
:) SWEATY HANDS :) OILY SNACKS :) AND BAD HYGIENE :)

45
src/Box.cpp
View File

@ -1,45 +1,51 @@
#include "Box.hpp"
Box::Box(const glm::vec2& nw, const glm::vec2& size) : rect({nw.x, nw.y, size.x, size.y}) {}
Box::Box(const glm::vec2& nw, const glm::vec2& size)
{
x = nw.x;
y = nw.y;
w = size.x;
h = size.y;
}
float Box::get_x() const
{
return rect.x;
return x;
}
float Box::get_y() const
{
return rect.y;
return y;
}
float Box::get_w() const
{
return rect.w;
return w;
}
float Box::get_h() const
{
return rect.h;
return h;
}
void Box::set_x(float x)
{
rect.x = x;
this->x = x;
}
void Box::set_y(float y)
{
rect.y = y;
this->y = y;
}
void Box::set_w(float w)
void Box::set_w(float width)
{
rect.w = w;
w = width;
}
void Box::set_h(float h)
void Box::set_h(float height)
{
rect.h = h;
h = height;
}
glm::vec2 Box::get_size() const
@ -238,19 +244,12 @@ void Box::set_center(const glm::vec2& center)
move(center - get_center());
}
SDL_FRect* Box::get_rect()
{
return ▭
}
SDL_Rect Box::get_int_rect() const
{
return {static_cast<int>(rect.x), static_cast<int>(rect.y), static_cast<int>(rect.w), static_cast<int>(rect.h)};
}
Box::operator SDL_Rect() const
{
return {static_cast<int>(rect.x), static_cast<int>(rect.y), static_cast<int>(rect.w), static_cast<int>(rect.h)};
return {
static_cast<int>(get_x()), static_cast<int>(get_y()),
static_cast<int>(get_w()), static_cast<int>(get_h())
};
}
void Box::clear()
@ -327,7 +326,7 @@ bool Box::collide(const Box& box, Box& overlap) const
std::ostream& Box::to_string (std::ostream& out) const
{
out << "{(" << rect.x << ", " << rect.y << "), (" << rect.w << ", " << rect.h << ")}";
out << "{(" << get_x() << ", " << get_y() << "), (" << get_w() << ", " << get_h() << ")}";
return out;
}

10
src/Box.hpp
View File

@ -12,11 +12,9 @@
struct Segment;
struct Box
struct Box : SDL_FRect
{
SDL_FRect rect = {0, 0, 0, 0};
Box(const glm::vec2& = {0, 0}, const glm::vec2& = {0, 0});
float get_x() const;
float get_y() const;
@ -60,16 +58,14 @@ struct Box
void set_south(const glm::vec2&);
void set_west(const glm::vec2&);
void set_center(const glm::vec2&);
SDL_FRect* get_rect();
SDL_Rect get_int_rect() const;
operator SDL_Rect() const;
void clear();
void scale(float, bool = false);
void move(const glm::vec2&);
bool collide(const glm::vec2&) const;
bool collide(const Segment&, glm::vec2* = NULL) const;
bool collide(const Segment&, glm::vec2* = nullptr) const;
bool collide(const Segment&, glm::vec2&) const;
bool collide(const Box&, Box* = NULL) const;
bool collide(const Box&, Box* = nullptr) const;
bool collide(const Box&, Box&) const;
std::string get_class_name() { return "Box"; }
std::ostream& to_string (std::ostream&) const;

39
src/Color.cpp
View File

@ -34,6 +34,45 @@ void Color::shift_hue(float offset)
set_percent(red_percent, green_percent, blue_percent);
}
Color::operator std::uint32_t() const
{
SDL_PixelFormat* format = SDL_AllocFormat(SDL_PIXELFORMAT_RGBA32);
std::uint32_t pixel = SDL_MapRGBA(format, r, g, b, a);
SDL_FreeFormat(format);
return pixel;
}
Color::operator std::uint16_t() const
{
SDL_PixelFormat* format = SDL_AllocFormat(SDL_PIXELFORMAT_RGBA4444);
std::uint16_t pixel = SDL_MapRGBA(format, r, g, b, a);
SDL_FreeFormat(format);
return pixel;
}
Color::operator std::uint8_t() const
{
SDL_PixelFormat* format = SDL_AllocFormat(SDL_PIXELFORMAT_RGB332);
std::uint8_t pixel = SDL_MapRGBA(format, r, g, b, a);
SDL_FreeFormat(format);
return pixel;
}
bool Color::operator==(const Color& color) const
{
return r == color.r && g == color.g && b == color.b && a == color.a;
}
bool Color::operator!=(const Color& color) const
{
return !(*this == color);
}
bool Color::operator<(const Color& color) const
{
return r < color.r || g < color.g || b < color.b || a < color.a;
}
std::ostream& operator<<(std::ostream& out, const Color& color)
{
float h, s, v;

7
src/Color.hpp
View File

@ -8,7 +8,6 @@
#include <type_traits>
#include "SDL_pixels.h"
#include "extension.hpp"
struct Color : SDL_Color
{
@ -19,6 +18,12 @@ struct Color : SDL_Color
void set_percent(const float&, const float&, const float&, const float&);
void set_hsv(const float&, const float& = 1.0f, const float& = 1.0f);
void shift_hue(float);
operator std::uint32_t() const;
operator std::uint16_t() const;
operator std::uint8_t() const;
bool operator==(const Color&) const;
bool operator!=(const Color&) const;
bool operator<(const Color&) const;
template <typename T>
Color(T red, T green, T blue, T alpha = 255)

36
src/Pixels.cpp
View File

@ -58,32 +58,9 @@ int Pixels::get_bytes_per_row() const
return format->BytesPerPixel * rect.w;
}
void* Pixels::operator()(int x, int y)
Color Pixels::get(int x, int y)
{
std::uint8_t* access = static_cast<std::uint8_t*>(source);
if (x < 0 || x >= rect.w)
{
x = sfw::mod(x, static_cast<int>(rect.w));
}
if (y < 0 || y >= rect.y)
{
y = sfw::mod(y, static_cast<int>(rect.h));
}
return access + y * get_bytes_per_row() + x * format->BytesPerPixel;
}
Color Pixels::operator()(int x, int y) const
{
std::uint8_t* access = static_cast<std::uint8_t*>(source);
if (x < 0 || x >= rect.w)
{
x = sfw::mod(x, static_cast<int>(rect.w));
}
if (y < 0 || x >= rect.y)
{
y = sfw::mod(y, static_cast<int>(rect.h));
}
Uint32* pixel = reinterpret_cast<Uint32*>(access + y * get_bytes_per_row() + x * format->BytesPerPixel);
std::uint32_t* pixel = operator()<std::uint32_t*>(x, y);
Color color;
SDL_GetRGBA(*pixel, const_cast<SDL_PixelFormat*>(format), &color.r, &color.g, &color.b, &color.a);
return color;
@ -94,18 +71,15 @@ void Pixels::set(const SDL_Color& color, int x, int y)
std::uint32_t pixel = SDL_MapRGBA(const_cast<SDL_PixelFormat*>(format), color.r, color.g, color.b, color.a);
if (format->BytesPerPixel == 1)
{
std::uint8_t* access = reinterpret_cast<std::uint8_t*>((*this)(x, y));
*access = static_cast<std::uint8_t>(pixel);
*operator()<std::uint8_t*>(x, y) = pixel;
}
else if (format->BytesPerPixel == 2)
{
std::uint16_t* access = reinterpret_cast<std::uint16_t*>((*this)(x, y));
*access = static_cast<std::uint16_t>(pixel);
*operator()<std::uint16_t*>(x, y) = pixel;
}
else
{
std::uint32_t* access = reinterpret_cast<std::uint32_t*>((*this)(x, y));
*access = static_cast<std::uint32_t>(pixel);
*operator()<std::uint32_t*>(x, y) = pixel;
}
}

18
src/Pixels.hpp
View File

@ -23,12 +23,26 @@ struct Pixels
Pixels(Sprite&);
Pixels(Sprite&, const SDL_Rect&);
int get_bytes_per_row() const;
void* operator()(int x, int y);
Color operator()(int x, int y) const;
Color get(int x, int y);
void set(const SDL_Color&, int x, int y);
void apply();
~Pixels();
template <typename T = void*>
T operator()(int x, int y)
{
std::uint8_t* access = static_cast<std::uint8_t*>(source);
if (x < 0 || x >= rect.w)
{
x = sfw::mod(x, static_cast<int>(rect.w));
}
if (y < 0 || y >= rect.y)
{
y = sfw::mod(y, static_cast<int>(rect.h));
}
return reinterpret_cast<T>(access + y * get_bytes_per_row() + x * format->BytesPerPixel);
}
};
#endif

17
src/Sprite.cpp
View File

@ -105,6 +105,11 @@ void Sprite::add_frames(const std::vector<SDL_Texture*>& frames)
}
}
const std::vector<SDL_Texture*>& Sprite::get_frames() const
{
return frames;
}
Frameset& Sprite::get_all_frames_frameset()
{
return framesets[get_configuration()["animation"]["all-frames-frameset-name"]];
@ -674,12 +679,12 @@ void Sprite::update()
SDL_SetRenderTarget(renderer, NULL);
if (wrap.x || wrap.y)
{
SDL_Rect wrap_frame_rect = wrap_frame.get_int_rect();
SDL_Rect wrap_frame_rect = wrap_frame;
SDL_RenderSetClipRect(renderer, &wrap_frame_rect);
}
for (auto ii = 0; ii < static_cast<int>(boxes.size()); ii++)
{
SDL_RenderCopyF(renderer, texture, NULL, boxes[ii].get_rect());
SDL_RenderCopyF(renderer, texture, NULL, &boxes[ii]);
}
if (wrap.x || wrap.y)
{
@ -745,11 +750,11 @@ glm::vec2 Frameset::measure() const
int w, h;
for (std::size_t index : order)
{
if (index < sprite->frames.size())
if (index < sprite->get_frames().size())
{
SDL_QueryTexture(sprite->frames[index], NULL, NULL, &w, &h);
s.x = std::max(static_cast<float>(w * sprite->scale), s.x);
s.y = std::max(static_cast<float>(h * sprite->scale), s.y);
SDL_QueryTexture(sprite->get_frames()[index], nullptr, nullptr, &w, &h);
s.x = std::max(static_cast<float>(w * sprite->get_scale()), s.x);
s.y = std::max(static_cast<float>(h * sprite->get_scale()), s.y);
}
}
return s;

15
src/Sprite.hpp
View File

@ -15,7 +15,6 @@
#include "Box.hpp"
#include "Animation.hpp"
#include "Color.hpp"
#include "extension.hpp"
struct Game;
struct Frameset;
@ -43,12 +42,13 @@ struct Sprite : Node
Sprite();
Sprite(Node*);
Sprite(Node*, std::string);
void reset();
void associate(std::string);
void load();
virtual void reset();
virtual void associate(std::string);
virtual void load();
void load_file(fs::path);
void add_frames(SDL_Texture*);
void add_frames(const std::vector<SDL_Texture*>&);
const std::vector<SDL_Texture*>& get_frames() const;
Frameset& get_all_frames_frameset();
Frameset& add_frameset(std::string);
Frameset& set_frameset(std::string);
@ -109,7 +109,7 @@ struct Sprite : Node
void add_wrap(bool, bool);
void add_wrap(bool, bool, Box);
void add_hue_shift_frames(int);
glm::vec2 move(glm::vec2, bool = true);
virtual glm::vec2 move(glm::vec2, bool = true);
bool collide(const glm::vec2&, bool = false) const;
bool collide(const Segment&, glm::vec2* = NULL, bool = false) const;
bool collide(const Segment&, glm::vec2&, bool = false) const;
@ -117,8 +117,8 @@ struct Sprite : Node
bool collide(const Box&, Box&, bool = false, bool = false) const;
bool collide(const Sprite&, bool = false, Box* = NULL, bool = false, bool = false) const;
bool collide(const Sprite&, Box&, bool = false, bool = false, bool = false) const;
void update();
std::string get_class_name() { return "Sprite"; }
virtual void update();
virtual std::string get_class_name() { return "Sprite"; }
~Sprite() { unload(); }
};
@ -158,5 +158,6 @@ struct Frameset
#include "Pixels.hpp"
#include "Game.hpp"
#include "extension.hpp"
#endif

122
src/extension.cpp
View File

@ -69,7 +69,7 @@ void sfw::populate_pixel_2d_array(
int bytes_per_row = bytes_per_pixel * region.get_w();
int bytes_total = bytes_per_row * region.get_h();
Uint8* source = new Uint8[bytes_total];
SDL_Rect int_rect = region.get_int_rect();
SDL_Rect int_rect = region;
if (SDL_RenderReadPixels(renderer, &int_rect, format, source, bytes_per_row) < 0)
{
print_sdl_error("Could not read pixels after setting remapped texture as target");
@ -139,8 +139,7 @@ std::vector<SDL_Texture*> sfw::get_portal_frames(
frames.reserve(count);
float y_margin = 10;
float max_y = size.y - y_margin;
std::vector<float> hues = range_step(hue_start, hue_end, count);
std::cout << hues << std::endl;
std::vector<float> hues = range_count(hue_start, hue_end, count);
SDL_Texture* frame;
Color color;
for (int frame_ii = 0; frame_ii < count; frame_ii++)
@ -159,40 +158,79 @@ std::vector<SDL_Texture*> sfw::get_portal_frames(
return frames;
}
void sfw::fill_texture(SDL_Renderer* renderer, SDL_Texture* texture, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
void sfw::fill_texture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Color& color, const Box& box)
{
SDL_SetRenderTarget(renderer, texture);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
SDL_SetRenderDrawColor(renderer, r, g, b, a);
SDL_RenderFillRect(renderer, NULL);
SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a);
SDL_RenderFillRectF(renderer, &box);
}
void sfw::fill_texture(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Texture* tile)
void sfw::fill_texture(SDL_Renderer* renderer, SDL_Texture* texture, const SDL_Color& color)
{
fill_texture(renderer, texture, color, get_texture_box(texture));
}
void sfw::fill_texture(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Texture* tile, const Box& box)
{
SDL_SetRenderTarget(renderer, texture);
Box texture_box = get_texture_box(texture), tile_box = get_texture_box(tile);
SDL_FRect draw_rect;
for (int x = 0; x < texture_box.get_w(); x += tile_box.get_w())
if (SDL_SetRenderTarget(renderer, texture) < 0)
{
for (int y = 0; y < texture_box.get_h(); y += tile_box.get_h())
print_sdl_error("could not set render target");
}
else
{
SDL_Rect int_rect = box;
if (SDL_RenderSetClipRect(renderer, &int_rect) < 0)
{
draw_rect = {(float) x, (float) y, tile_box.get_w(), tile_box.get_h()};
SDL_RenderCopyF(renderer, tile, NULL, &draw_rect);
print_sdl_error("could not set clip");
}
else
{
for (int x = 0; x < texture_box.get_w(); x += tile_box.get_w())
{
for (int y = 0; y < texture_box.get_h(); y += tile_box.get_h())
{
draw_rect = {(float) x, (float) y, tile_box.get_w(), tile_box.get_h()};
SDL_RenderCopyF(renderer, tile, nullptr, &draw_rect);
}
}
SDL_RenderSetClipRect(renderer, nullptr);
}
}
}
void sfw::fill_texture(SDL_Renderer* renderer, SDL_Texture* texture, SDL_Texture* tile)
{
fill_texture(renderer, texture, tile, get_texture_box(texture));
}
SDL_Texture* sfw::get_filled_texture(SDL_Renderer* renderer, glm::vec2 size, const SDL_Color& color, Uint32 format)
{
SDL_Texture* texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_TARGET, size.x, size.y);
sfw::fill_texture(renderer, texture, color.r, color.g, color.b, color.a);
SDL_Texture* texture;
if ((texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_TARGET, size.x, size.y)) == nullptr)
{
print_sdl_error("could not create texture to fill");
}
else
{
sfw::fill_texture(renderer, texture, color);
}
return texture;
}
SDL_Texture* sfw::get_filled_texture(SDL_Renderer* renderer, glm::vec2 size, SDL_Texture* tile, Uint32 format)
{
SDL_Texture* texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_TARGET, size.x, size.y);
sfw::fill_texture(renderer, texture, tile);
SDL_Texture* texture;
if ((texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_TARGET, size.x, size.y)) == nullptr)
{
print_sdl_error("could not create texture to fill");
}
else
{
sfw::fill_texture(renderer, texture, tile);
}
return texture;
}
@ -275,7 +313,7 @@ SDL_Texture* sfw::duplicate_texture(SDL_Renderer* renderer, SDL_Texture* base, c
}
SDL_Texture* sfw::get_remapped_texture(
SDL_Renderer* renderer, SDL_Texture* base, const std::map<SDL_Color, SDL_Color>& map)
SDL_Renderer* renderer, SDL_Texture* base, const std::map<Color, Color>& map)
{
SDL_Texture* remapped = duplicate_texture(renderer, base);
if (remapped == nullptr)
@ -288,50 +326,26 @@ SDL_Texture* sfw::get_remapped_texture(
print_sdl_error("could not set render target to remapped texture");
return nullptr;
}
Box box = get_texture_box(remapped);
std::uint32_t format;
SDL_QueryTexture(remapped, &format, nullptr, nullptr, nullptr);
int bytes_per_pixel = SDL_BYTESPERPIXEL(format);
int bytes_total = bytes_per_pixel * box.get_w() * box.get_h();
unsigned char* pixels = new unsigned char[bytes_total];
if ((SDL_RenderReadPixels(renderer, nullptr, format, pixels, bytes_total / box.get_h())) < 0)
Pixels pixels = Pixels(renderer, remapped);
for (int x = 0; x < pixels.rect.w; x++)
{
print_sdl_error("could not read pixels after setting remapped texture as target");
return nullptr;
}
SDL_Color color;
for (int ii = 0; ii < bytes_total; ii += bytes_per_pixel)
{
color = {pixels[ii], pixels[ii + 1], pixels[ii + 2], 255};
if (bytes_per_pixel == 4)
for (int y = 0; y < pixels.rect.h; y++)
{
color.a = pixels[ii + 3];
}
for (auto& pair : map)
{
if (color.r == pair.first.r && color.g == pair.first.g && color.b == pair.first.b &&
(bytes_per_pixel < 4 || color.a == pair.first.a))
for (auto& [original, replacement] : map)
{
pixels[ii] = pair.second.r;
pixels[ii + 1] = pair.second.g;
pixels[ii + 2] = pair.second.b;
if (bytes_per_pixel == 4)
if (pixels.get(x, y) == original)
{
pixels[ii + 3] = pair.second.a;
pixels.set(replacement, x, y);
}
}
}
}
if (SDL_UpdateTexture(remapped, nullptr, pixels, bytes_total / box.get_h()) < 0)
{
print_sdl_error("could not update remapped texture");
}
delete[] pixels;
pixels.apply();
return remapped;
}
SDL_Texture* sfw::get_remapped_texture(
SDL_Renderer* renderer, const std::string& path, const std::map<SDL_Color, SDL_Color>& map)
SDL_Renderer* renderer, const std::string& path, const std::map<Color, Color>& map)
{
SDL_Texture* base = IMG_LoadTexture(renderer, path.c_str());
if (base == nullptr)
@ -530,16 +544,6 @@ std::ostream& operator<<(std::ostream& out, const glm::vec2& vector)
return out;
}
bool operator<(const SDL_Color& color_1, const SDL_Color& color_2)
{
return color_1.r < color_2.r || color_1.g < color_2.g || color_1.b < color_2.b || color_1.a < color_2.a;
}
bool operator==(const SDL_Color& color_1, const SDL_Color& color_2)
{
return color_1.r == color_2.r && color_1.g == color_2.g && color_1.b == color_2.b && color_1.a == color_2.a;
}
std::ostream& operator<<(std::ostream& out, const SDL_Color& color)
{
out << "{" << static_cast<int>(color.r) << ", " << static_cast<int>(color.g) << ", " <<

93
src/extension.hpp
View File

@ -44,15 +44,17 @@ namespace sfw
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*, Uint8, Uint8, Uint8, Uint8 = 0xff);
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<SDL_Color, SDL_Color>&);
SDL_Texture* get_remapped_texture(SDL_Renderer*, const std::string&, const std::map<SDL_Color, SDL_Color>&);
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(
@ -94,49 +96,71 @@ namespace sfw
return padded.str();
}
template <typename N>
std::vector<N> range_step(N start, N end, int count)
template <typename N, typename N2 = N>
std::vector<N2> range(N start, N stop, N2 step)
{
float step = (end - start) / (count - 1);
std::vector<N> nums;
nums.reserve(count);
for (int ii = 0; ii < count; ii++)
{
nums.push_back(start + ii * step);
}
return nums;
}
// from https://stackoverflow.com/a/30312659/1256386
template <typename IntType>
std::vector<IntType> range(IntType start, IntType stop, IntType step)
{
if (step == IntType(0))
if (step == N2(0))
{
throw std::invalid_argument("step for range must be non-zero");
}
std::vector<IntType> result;
IntType i = start;
while ((step > 0) ? (i < stop) : (i > stop))
std::vector<N2> result;
while ((step > 0) ? (start < stop) : (start > stop))
{
result.push_back(i);
i += step;
result.push_back(start);
start += step;
}
return result;
}
// from https://stackoverflow.com/a/30312659/1256386
template <typename IntType>
std::vector<IntType> range(IntType start, IntType stop)
template <typename N>
std::vector<N> range(N start, N stop)
{
return range(start, stop, IntType(1));
return range(start, stop, N(1));
}
// from https://stackoverflow.com/a/30312659/1256386
template <typename IntType>
std::vector<IntType> range(IntType stop)
template <typename N>
std::vector<N> range(N stop)
{
return range(IntType(0), stop, IntType(1));
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;
}
}
@ -154,8 +178,6 @@ std::ostream& operator<<(std::ostream& out, const std::vector<T>& members)
}
std::ostream& operator<<(std::ostream&, const glm::vec2&);
bool operator<(const SDL_Color& color_1, const SDL_Color& color_2);
bool operator==(const SDL_Color& color_1, const SDL_Color& color_2);
std::ostream& operator<<(std::ostream&, const SDL_Color&);
namespace glm
@ -175,5 +197,6 @@ namespace glm
}
#include "Node.hpp"
#include "Pixels.hpp"
#endif