box.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    2024-05-01
// Version V1.0.0
//##################################################################################################
 
#pragma once
 
// bitten by these ancient macros. They can't remove them, that would break old code. 
// https://stackoverflow.com/questions/6884093/warning-c4003-not-enough-actual-parameters-for-macro-max-visual-studio-2010
#undef min
#undef max
 
#include "tuple.h"
 
namespace cil
{
    class Vector2i;
    class Vector2f;
    class Vector3i;
    class Vector3f;
    class Float32Array;
 
    template<typename T>
    class Box : public Tuple<T>
    {
    public:
        Box(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];
        }
    };
 
    template<typename T, typename S>
    class Box2 : public Box<T>
    {
    public:
        Box2()
            : Box<T>(4)
        {
        }
        void set(T xmin, T xmax, T ymin, T ymax)
        {
            this->m_data[0] = xmin;
            this->m_data[1] = xmax;
            this->m_data[2] = ymin;
            this->m_data[3] = ymax;
        }
        void set(const S& min, const S& max)
        {
            this->setMin(min);
            this->setMax(max);
        }
        S min() const
        {
            return S(this->m_data[0], this->m_data[2]);
        }
        void setMin(const S& min)
        {
            this->m_data[0] = min.data()[0];
            this->m_data[2] = min.data()[1];
        }
        S max() const
        {
            return S(this->m_data[1], this->m_data[3]);
        }
        void setMax(const S& max)
        {
            this->m_data[1] = max.data()[0];
            this->m_data[3] = max.data()[1];
        }
        S center() const
        {
            return (this->min() + this->max()) / 2.0f;
        }
        S extent() const
        {
            return this->max() - this->min();
        }
    };
 
    class Box2i final : public Box2<int, Vector2i>
    {
    public:
        Box2i(); 
        Box2i(int xmin, int xmax, int ymin, int ymax);
        Box2i(const Vector2i& min, const Vector2i& max);
        Box2i(const Box2i& other);
    };
    class Box2f final : public Box2<float, Vector2f>
    {
    public:
        Box2f();
        Box2f(float xmin, float xmax, float ymin, float ymax);
        Box2f(const Vector2f& min, const Vector2f& max);
        Box2f(const Box2f& other);
    };
 
    template<typename T, typename S>
    class Box3 : public Box<T>
    {
    public:
        Box3()
            : Box<T>(6)
        {
        }
        void set(T xmin, T xmax, T ymin, T ymax, T zmin, T zmax)
        {
            this->m_data[0] = xmin;
            this->m_data[1] = xmax;
            this->m_data[2] = ymin;
            this->m_data[3] = ymax;
            this->m_data[4] = zmin;
            this->m_data[5] = zmax;
        }
 
        void set(const S& min, const S& max)
        {
            this->setMin(min);
            this->setMax(max);
        }
        S min() const
        {
            return S(this->m_data[0], this->m_data[2], this->m_data[4]);
        }
 
        void setMin(const S& min)
        {
            this->m_data[0] = min.data()[0];
            this->m_data[2] = min.data()[1];
            this->m_data[4] = min.data()[2];
        }
        S max() const
        {
            return S(this->m_data[1], this->m_data[3], this->m_data[5]);
        }
        void setMax(const S& max)
        {
            this->m_data[1] = max.data()[0];
            this->m_data[3] = max.data()[1];
            this->m_data[5] = max.data()[2];
        }
        S center() const
        {
            return (this->min() + this->max()) / 2.0f;
        }
        S extent() const
        {
            return this->max() - this->min();
        }
    };
 
    class Box3i final : public Box3<int, Vector3i>
    {
    public:
        Box3i();
        Box3i(int xmin, int xmax, int ymin, int ymax, int zmin, int zmax);
        Box3i(const Vector3i& min, const Vector3i& max);
        Box3i(const Box3i& other);
    };
 
    class Box3f final : public Box3<float, Vector3f>
    {
    public:
        Box3f();
        Box3f(float xmin, float xmax, float ymin, float ymax, float zmin, float zmax);
        Box3f(const Vector3f& min, const Vector3f& max);
        Box3f(const Box3f& other);
    };
 
    class BoundingBox final : public Box3<float, Vector3f>
    {
    public:
        BoundingBox(); 
        BoundingBox(const BoundingBox& other);
        BoundingBox(float xmin, float xmax, float ymin, float ymax, float zmin, float zmax); 
        BoundingBox(const Vector3f& min, const Vector3f& max);
 
        BoundingBox& operator+=(const BoundingBox& other); 
        BoundingBox& operator+=(Vector3f value);
 
        bool isValid() const; 
        bool inRange(Vector3f value) const; 
        void addPoint(float x, float y, float z);
        void addPoint(const Vector3f& point);
        void addPoints(const Float32Array& points);
    };
 
    using box2 = Box2f;
    using ibox2 = Box2i;
    using box3 = Box3f;
    using ibox3 = Box3i;
    using bbox = BoundingBox;
}