color.h

//##################################################################################################
//
// Copyright (c) 2024 Beijing Qiongqi Tech Co.,Ltd. All rights reserved. 
 
// This source code is confidential and proprietary to Beijing Qiongqi Tech Co.,Ltd(The Holder). 
// Any unauthorized use, copying, modification, or distribution of the code is strictly prohibited. 
// Any user shall obtain authorizaition from the Holder before modifying the source code. And the user shall not
// sublicense, sell, distribute, or transfer the source code, whether in original or modified form, to any third party
// without the prior written consent of the Holder.
 
// This copyright notice and permission grant shall be included in all copies or substantial portions of the source code.
 
// Author  Cumulia Illustrator
// Date    2025-08-05
// Version V2.1.0
//##################################################################################################
 
#pragma once
 
#include "tuple.h"
 
namespace cil
{
    class Color3f;
    class Color3ub;
    class Color4f;
    class Color4ub;
 
    template<typename T>
    class Color : public Tuple<T>
    {
    public:
        Color(int size)
            : Tuple<T>(size)
        {
        }
        const T& operator[](int index) const
        {
            return this->m_data[index];
        }
        T& operator[](int index)
        {
            return this->m_data[index];
        }
        const T& operator[](char key) const
        {
            if (key == 'r')
                return this->m_data[0];
            if (key == 'g')
                return this->m_data[1];
            if (key == 'b')
                return this->m_data[2];
            if (key == 'a' && this->m_size == 4)
                return this->m_data[3];
 
            return this->m_data[0];
        }
        T& operator[](char key)
        {
            if (key == 'r')
                return this->m_data[0];
            if (key == 'g')
                return this->m_data[1];
            if (key == 'b')
                return this->m_data[2];
            if (key == 'a' && this->m_size == 4)
                return this->m_data[3];
 
            return this->m_data[0];
        }
    };
 
    template<typename T>
    class Color3 : public Color<T>
    {
    public:
        Color3()
            : Color<T>(3)
        {
        }
        void set(T r, T g, T b)
        {
            this->m_data[0] = r;
            this->m_data[1] = g;
            this->m_data[2] = b;
        }
    };
 
    class Color3f final : public Color3<float>
    {
    public:
        Color3f(); 
        Color3f(float r, float g, float b); 
        Color3f(const Color3f& other);
        Color3f(const Color3ub& other); 
        Color3f(const Color4f& other);
        Color3f(const Color4ub& other);
    };
    class Color3ub final : public Color3<unsigned char>
    {
    public:
        Color3ub(); 
        Color3ub(unsigned char r, unsigned char g, unsigned char b); 
        Color3ub(const Color3ub& other);
        Color3ub(const Color3f& other); 
        Color3ub(const Color4ub& other);
        Color3ub(const Color4f& other);
    };
    template<typename T>
    class Color4 : public Color<T>
    {
    public:
        Color4()
            : Color<T>(4)
        {
        }
        void set(T r, T g, T b, T a)
        {
            this->m_data[0] = r;
            this->m_data[1] = g;
            this->m_data[2] = b;
            this->m_data[3] = a;
        }
    };
    class Color4f final : public Color4<float>
    {
    public:
        Color4f(); 
        Color4f(float r, float g, float b, float a); 
        Color4f(const Color4f& other);
        Color4f(const Color3f& other);  
        Color4f(const Color4ub& other); 
        Color4f(const Color3ub& other);
    };
    class Color4ub final : public Color4<unsigned char>
    {
    public:
        Color4ub(); 
        Color4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
        Color4ub(const Color4ub& other);
        Color4ub(const Color4f& other); 
        Color4ub(const Color3ub& other);
        Color4ub(const Color3f& other); 
    };
 
    using clr3 = Color3f;
    using clr3ub = Color3ub;
    using clr4 = Color4f;
    using clr4ub = Color4ub;
}