mirror of https://github.com/AxioDL/zeus.git
312 lines
8.0 KiB
C++
312 lines
8.0 KiB
C++
#pragma once
|
|
|
|
#include "Global.hpp"
|
|
#include "zeus/Math.hpp"
|
|
#include "CVector4f.hpp"
|
|
|
|
#if ZE_ATHENA_TYPES
|
|
|
|
#include "athena/FileReader.hpp"
|
|
#include "athena/FileWriter.hpp"
|
|
|
|
#endif
|
|
|
|
#include <iostream>
|
|
#include <cassert>
|
|
|
|
#undef min
|
|
#undef max
|
|
|
|
#if BYTE_ORDER == __ORDER_LITTLE_ENDIAN__
|
|
#define COLOR(rgba) \
|
|
(unsigned)(((rgba)&0x000000FF) << 24 | ((rgba)&0x0000FF00) << 8 | ((rgba)&0x00FF0000) >> 8 | \
|
|
((rgba)&0xFF000000) >> 24)
|
|
#else
|
|
#define COLOR(rgba) rgba
|
|
#endif
|
|
|
|
namespace zeus {
|
|
typedef uint8_t Comp8;
|
|
typedef uint32_t Comp32;
|
|
constexpr float OneOver255 = 1.f / 255.f;
|
|
|
|
typedef union {
|
|
struct {
|
|
Comp8 r, g, b, a;
|
|
};
|
|
Comp32 rgba;
|
|
} RGBA32;
|
|
|
|
class CVector4f;
|
|
|
|
class CColor {
|
|
public:
|
|
simd<float> mSimd;
|
|
static const CColor skRed;
|
|
static const CColor skBlack;
|
|
static const CColor skBlue;
|
|
static const CColor skGreen;
|
|
static const CColor skGrey;
|
|
static const CColor skOrange;
|
|
static const CColor skPurple;
|
|
static const CColor skYellow;
|
|
static const CColor skWhite;
|
|
static const CColor skClear;
|
|
|
|
CColor() : mSimd(1.f) {}
|
|
|
|
CColor(float rgb, float a = 1.0) { splat(rgb, a); }
|
|
|
|
CColor(float r, float g, float b, float a = 1.0f) : mSimd(r, g, b, a) {}
|
|
|
|
#if ZE_ATHENA_TYPES
|
|
|
|
CColor(const atVec4f& vec) : mSimd(vec.simd) {}
|
|
|
|
#endif
|
|
|
|
CColor(Comp32 rgba) { fromRGBA32(rgba); }
|
|
|
|
CColor(const Comp8* rgba) { fromRGBA8(rgba[0], rgba[1], rgba[2], rgba[3]); }
|
|
|
|
CColor(const CVector4f& other) : mSimd(other.mSimd) {}
|
|
|
|
template <typename T>
|
|
CColor(const simd<T>& s) : mSimd(s) {}
|
|
|
|
CColor& operator=(const CVector4f& other) {
|
|
mSimd = other.mSimd;
|
|
return *this;
|
|
}
|
|
|
|
#if ZE_ATHENA_TYPES
|
|
|
|
static CColor ReadRGBABig(athena::io::IStreamReader& reader) {
|
|
CColor ret;
|
|
ret.readRGBABig(reader);
|
|
return ret;
|
|
}
|
|
|
|
void readRGBABig(athena::io::IStreamReader& reader) {
|
|
simd_floats f;
|
|
f[0] = reader.readFloatBig();
|
|
f[1] = reader.readFloatBig();
|
|
f[2] = reader.readFloatBig();
|
|
f[3] = reader.readFloatBig();
|
|
mSimd.copy_from(f);
|
|
}
|
|
|
|
void readBGRABig(athena::io::IStreamReader& reader) {
|
|
simd_floats f;
|
|
f[2] = reader.readFloatBig();
|
|
f[1] = reader.readFloatBig();
|
|
f[0] = reader.readFloatBig();
|
|
f[3] = reader.readFloatBig();
|
|
mSimd.copy_from(f);
|
|
}
|
|
|
|
void writeRGBABig(athena::io::IStreamWriter& writer) const {
|
|
simd_floats f(mSimd);
|
|
writer.writeFloatBig(f[0]);
|
|
writer.writeFloatBig(f[1]);
|
|
writer.writeFloatBig(f[2]);
|
|
writer.writeFloatBig(f[3]);
|
|
}
|
|
|
|
void writeBGRABig(athena::io::IStreamWriter& writer) const {
|
|
simd_floats f(mSimd);
|
|
writer.writeFloatBig(f[2]);
|
|
writer.writeFloatBig(f[1]);
|
|
writer.writeFloatBig(f[0]);
|
|
writer.writeFloatBig(f[3]);
|
|
}
|
|
|
|
void writeRGBA8(athena::io::IStreamWriter& writer) const {
|
|
simd_floats f(mSimd);
|
|
writer.writeUByte(atUint8(f[0] * 255));
|
|
writer.writeUByte(atUint8(f[1] * 255));
|
|
writer.writeUByte(atUint8(f[2] * 255));
|
|
writer.writeUByte(atUint8(f[3] * 255));
|
|
}
|
|
|
|
#endif
|
|
|
|
bool operator==(const CColor& rhs) const {
|
|
return (r() == rhs.r() && g() == rhs.g() && b() == rhs.b() && a() == rhs.a());
|
|
}
|
|
|
|
bool operator!=(const CColor& rhs) const { return !(*this == rhs); }
|
|
|
|
CColor operator+(const CColor& rhs) const { return mSimd + rhs.mSimd; }
|
|
|
|
CColor operator-(const CColor& rhs) const { return mSimd - rhs.mSimd; }
|
|
|
|
CColor operator*(const CColor& rhs) const { return mSimd * rhs.mSimd; }
|
|
|
|
CColor operator/(const CColor& rhs) const { return mSimd / rhs.mSimd; }
|
|
|
|
CColor operator+(float val) const { return mSimd + simd<float>(val); }
|
|
|
|
CColor operator-(float val) const { return mSimd - simd<float>(val); }
|
|
|
|
CColor operator*(float val) const { return mSimd * simd<float>(val); }
|
|
|
|
CColor operator/(float val) const { return mSimd / simd<float>(val); }
|
|
|
|
const CColor& operator+=(const CColor& rhs) {
|
|
mSimd += rhs.mSimd;
|
|
return *this;
|
|
}
|
|
|
|
const CColor& operator-=(const CColor& rhs) {
|
|
mSimd -= rhs.mSimd;
|
|
return *this;
|
|
}
|
|
|
|
const CColor& operator*=(const CColor& rhs) {
|
|
mSimd *= rhs.mSimd;
|
|
return *this;
|
|
}
|
|
|
|
const CColor& operator/=(const CColor& rhs) {
|
|
mSimd /= rhs.mSimd;
|
|
return *this;
|
|
}
|
|
|
|
const CColor& operator+=(float rhs) {
|
|
mSimd += simd<float>(rhs);
|
|
return *this;
|
|
}
|
|
|
|
const CColor& operator-=(float rhs) {
|
|
mSimd -= simd<float>(rhs);
|
|
return *this;
|
|
}
|
|
|
|
const CColor& operator*=(float rhs) {
|
|
mSimd *= simd<float>(rhs);
|
|
return *this;
|
|
}
|
|
|
|
const CColor& operator/=(float rhs) {
|
|
mSimd /= simd<float>(rhs);
|
|
return *this;
|
|
}
|
|
|
|
void normalize() {
|
|
float mag = magnitude();
|
|
mag = 1.f / mag;
|
|
*this *= mag;
|
|
}
|
|
|
|
CColor normalized() const {
|
|
float mag = magnitude();
|
|
mag = 1.f / mag;
|
|
return *this * mag;
|
|
}
|
|
|
|
float magSquared() const { return mSimd.dot4(mSimd); }
|
|
|
|
float magnitude() const { return std::sqrt(magSquared()); }
|
|
|
|
static CColor lerp(const CColor& a, const CColor& b, float t) {
|
|
return zeus::simd<float>(1.f - t) * a.mSimd + b.mSimd * zeus::simd<float>(t);
|
|
}
|
|
|
|
static CColor nlerp(const CColor& a, const CColor& b, float t) { return lerp(a, b, t).normalized(); }
|
|
|
|
simd<float>::reference operator[](const size_t& idx) {
|
|
assert(idx < 4);
|
|
return mSimd[idx];
|
|
}
|
|
|
|
float operator[](const size_t& idx) const {
|
|
assert(idx < 4);
|
|
return mSimd[idx];
|
|
}
|
|
|
|
void splat(float rgb, float a) {
|
|
mSimd = simd<float>(rgb);
|
|
mSimd[3] = a;
|
|
}
|
|
|
|
float rgbDot(const CColor& rhs) const { return mSimd.dot3(rhs.mSimd); }
|
|
|
|
void fromRGBA8(const Comp8 ri, const Comp8 gi, const Comp8 bi, const Comp8 ai) {
|
|
mSimd = simd<float>(ri * OneOver255, gi * OneOver255, bi * OneOver255, ai * OneOver255);
|
|
}
|
|
|
|
void fromRGBA32(Comp32 rgba) {
|
|
static RGBA32 tmp;
|
|
tmp.rgba = COLOR(rgba);
|
|
fromRGBA8(tmp.r, tmp.g, tmp.b, tmp.a);
|
|
}
|
|
|
|
/*!
|
|
* \brief Converts a CColor to RGBA8
|
|
* \param r
|
|
* \param g
|
|
* \param b
|
|
* \param a
|
|
*/
|
|
void toRGBA8(Comp8& ro, Comp8& go, Comp8& bo, Comp8& ao) const {
|
|
ro = Comp8(r() * 255);
|
|
go = Comp8(g() * 255);
|
|
bo = Comp8(b() * 255);
|
|
ao = Comp8(a() * 255);
|
|
}
|
|
|
|
/**
|
|
* @brief Assigns rgba from hsv
|
|
* @param h[0-1] The hue percentagee of the color.
|
|
* @param s[0-1] The saturation percentage of the color.
|
|
* @param v[0-1] The value percentage of the color.
|
|
* @param a[0-1] The alpha percentage of the color.
|
|
*/
|
|
void fromHSV(float h, float s, float v, float _a = 1.0);
|
|
|
|
/**
|
|
* @brief Converts rgba to hsv
|
|
* @param h[0-1] The hue percentagee of the color.
|
|
* @param s[0-1] The saturation percentage of the color.
|
|
* @param v[0-1] The value percentage of the color.
|
|
* @param a[0-1] The alpha percentage of the color.
|
|
*/
|
|
void toHSV(float& h, float& s, float& v) const;
|
|
|
|
void fromHSL(float h, float s, float l, float _a = 1.0);
|
|
|
|
void toHSL(float& h, float& s, float& l) const;
|
|
|
|
CColor toGrayscale() const { return {std::sqrt((r() * r() + g() * g() + b() * b()) / 3), a()}; }
|
|
|
|
/**
|
|
* @brief Clamps to GPU-safe RGBA values [0,1]
|
|
*/
|
|
void Clamp() {
|
|
r() = std::min(1.f, std::max(0.f, float(r())));
|
|
g() = std::min(1.f, std::max(0.f, float(g())));
|
|
b() = std::min(1.f, std::max(0.f, float(b())));
|
|
a() = std::min(1.f, std::max(0.f, float(a())));
|
|
}
|
|
|
|
float r() const { return mSimd[0]; }
|
|
float g() const { return mSimd[1]; }
|
|
float b() const { return mSimd[2]; }
|
|
float a() const { return mSimd[3]; }
|
|
|
|
simd<float>::reference r() { return mSimd[0]; }
|
|
simd<float>::reference g() { return mSimd[1]; }
|
|
simd<float>::reference b() { return mSimd[2]; }
|
|
simd<float>::reference a() { return mSimd[3]; }
|
|
};
|
|
|
|
static inline CColor operator+(float lhs, const CColor& rhs) { return simd<float>(lhs) + rhs.mSimd; }
|
|
|
|
static inline CColor operator-(float lhs, const CColor& rhs) { return simd<float>(lhs) - rhs.mSimd; }
|
|
|
|
static inline CColor operator*(float lhs, const CColor& rhs) { return simd<float>(lhs) * rhs.mSimd; }
|
|
|
|
static inline CColor operator/(float lhs, const CColor& rhs) { return simd<float>(lhs) / rhs.mSimd; }
|
|
} // namespace zeus
|