GxStruct.inl

Go to the documentation of this file.

//===========================================================================
//===========================================================================
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
// GxFloat2
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat2::GxFloat2(const GxFloat3& float3)
: _x(float3._x)
, _y(float3._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat2::GxFloat2(const GxFloat4& float4)
: _x(float4._x)
, _y(float4._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat2::GxFloat2(const GxVector2& vector)
: _x(vector._x)
, _y(vector._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat2::GxFloat2(const GxVector3& vector)
: _x(vector._x)
, _y(vector._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat2::GxFloat2(const GxVector4& vector)
: _x(vector._x)
, _y(vector._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat2::GxFloat2(const GxPoint2& point)
: _x(static_cast<f32>(point._x))
, _y(static_cast<f32>(point._y))
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat2& GxFloat2::operator = (const GxVector2& vector)
{
    _x = vector._x;
    _y = vector._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat2& GxFloat2::operator = (const GxFloat2& float2)
{
    _x = float2._x;
    _y = float2._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat2& GxFloat2::operator = (const GxVector3& vector)
{
    _x = vector._x;
    _y = vector._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat2& GxFloat2::operator = (const GxVector4& vector)
{
    _x = vector._x;
    _y = vector._y;
    return *this;
}
 
//===========================================================================
// GxFloat3
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat3::GxFloat3(const GxFloat4& float4)
: _x(float4._x)
, _y(float4._y)
, _z(float4._z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat3::GxFloat3(const GxVector3& vector)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat3::GxFloat3(const GxVector4& vector) 
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat3& GxFloat3::operator = (const GxVector3& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
    return *this;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat3& GxFloat3::operator = (const GxVector4& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
    return *this;
}
 
//===========================================================================
// GxFloat4
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat4::GxFloat4(const GxVector4& vector)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
, _w(vector._w)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat4::GxFloat4(const GxQuaternion& quaternion)
: _x(quaternion._x)
, _y(quaternion._y)
, _z(quaternion._z)
, _w(quaternion._w)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat4& GxFloat4::operator = (const GxVector4& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
    _w = vector._w;
    return *this;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxFloat4& GxFloat4::operator = (const GxQuaternion& quaternion)
{
    _x = quaternion._x;
    _y = quaternion._y;
    _z = quaternion._z;
    _w = quaternion._w;
    return *this;
}
 
//===========================================================================
// GxDouble2
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble2::GxDouble2(const GxDouble3& double3)
: _x(double3._x)
, _y(double3._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble2::GxDouble2(const GxDouble4& double4)
: _x(double4._x)
, _y(double4._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble2::GxDouble2(const GxVector2d& vector)
: _x(vector._x)
, _y(vector._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble2::GxDouble2(const GxVector3d& vector)
: _x(vector._x)
, _y(vector._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble2::GxDouble2(const GxVector4d& vector)
: _x(vector._x)
, _y(vector._y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble2::GxDouble2(const GxPoint2& point)
: _x(static_cast<f64>(point._x))
, _y(static_cast<f64>(point._y))
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble2& GxDouble2::operator = (const GxVector2d& vector)
{
    _x = vector._x;
    _y = vector._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble2& GxDouble2::operator = (const GxDouble2& float2)
{
    _x = float2._x;
    _y = float2._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble2& GxDouble2::operator = (const GxVector3d& vector)
{
    _x = vector._x;
    _y = vector._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble2& GxDouble2::operator = (const GxVector4d& vector)
{
    _x = vector._x;
    _y = vector._y;
    return *this;
}
 
//===========================================================================
// GxDouble3
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble3::GxDouble3(const GxDouble4& double4)
: _x(double4._x)
, _y(double4._y)
, _z(double4._z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble3::GxDouble3(const GxVector3d& vector)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble3::GxDouble3(const GxVector4d& vector)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble3& GxDouble3::operator = (const GxVector3d& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
    return *this;
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble3& GxDouble3::operator = (const GxVector4d& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
    return *this;
}
 
//===========================================================================
// GxDouble4
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble4::GxDouble4(const GxVector4d& vector)
: _x(vector._x)
, _y(vector._y)
, _z(vector._z)
, _w(vector._w)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxDouble4& GxDouble4::operator = (const GxVector4d& vector)
{
    _x = vector._x;
    _y = vector._y;
    _z = vector._z;
    _w = vector._w;
    return *this;
}
 
//===========================================================================
// ! 16bit浮動小数
//===========================================================================
//---------------------------------------------------------------------------
// デフォルトコンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxF16::GxF16(void)
: _value(0)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxF16::GxF16( f32 valueF32)
{
    _value = f32ToF16(valueF32).getValueU16();
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxF16::GxF16( const GxF16& valueF16)
{
    _value = valueF16._value;
}
 
//---------------------------------------------------------------------------
// 32ビットフロートキャスト
//---------------------------------------------------------------------------
GX_INLINE GxF16::operator f32() const
{
    return f16ToF32(*this);
}
 
//---------------------------------------------------------------------------
// 32ビットから16ビットの変換
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxF16 GxF16::f32ToF16(f32 valueF32)
{
    union f32union
    {
        u32     integerValue;
        f32     floatValue;
    };
    GxF16 zeroF16;
    zeroF16._value = 0;
 
    f32union convertWork;
    convertWork.floatValue = valueF32;
    auto integerValue = convertWork.integerValue;
 
    if (!integerValue)
    {
        return zeroF16;
    }
    /* IEEE754形式 浮動小数
 
    float
 
     sign(符号) ┌── exponent(指数) ───┐  ┌───────────────── fraction(仮数) ──────────────────┐
          ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
          │　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│
          └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
            31  30                          23  22                                                                                         0
 
    half-float
 
     sign(符号) ┌exponent(指数)┐  ┌───── fraction(仮数) ──────┐
          ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
          │　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│　│
          └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
            16  15              11  10                                       0
 
    */
 
    s32 exponent = ((integerValue & 0x7f800000) >> 23) - 127 + 15;
    if (exponent < 0)
    {
        return zeroF16;
    }
    else if (exponent > 31)
    {
        exponent = 31;
    }
    s32 sign        = integerValue & 0x80000000;
    s32 fraction    = integerValue & 0x007fffff;
 
    GxF16 returnValue;
    returnValue.setValueU16( ((sign >> 16) & 0x8000) | ((exponent << 10) & 0x7c00) | ((fraction >> 13) & 0x03ff) );
 
    return returnValue;
}
 
//---------------------------------------------------------------------------
// 16ビットから32ビットの変換
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxF16::f16ToF32(GxF16 valueF16)
{
    union f32union
    {
        u32     integerValue;
        f32     floatValue;
    };
 
    if (!valueF16.getValueU16())
    {
        return 0.0f;
    }
    u32 sign        = valueF16.getValueU16() & 0x8000;                      //1 00000 0000000000
    s32 exponent    = ((valueF16.getValueU16() & 0x7c00) >>10) - 15 + 127;  //0 11111 0000000000
    u32 fraction    = valueF16.getValueU16() & 0x03ff;                      //0 00000 1111111111
 
    f32union convertWork;
    convertWork.integerValue = (sign << 16) | ((exponent << 23) & 0x7f800000) | (fraction << 13);
 
    return convertWork.floatValue;
}
 
//===========================================================================
// GxF16x2
//===========================================================================
//---------------------------------------------------------------------------
// operator = 
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxF16x2& GxF16x2::operator = (const GxF16x2& value)
{
    _value[0] = value._value[0];
    _value[1] = value._value[1];
 
    return *this;
}
 
//---------------------------------------------------------------------------
// operator = 
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxF16x2& GxF16x2::operator = (const GxFloat2& value)
{
    _value[0] = value._x;
    _value[1] = value._y;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// operator = 
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxF16x2& GxF16x2::operator = (const GxVector2& value)
{
    _value[0] = value._x;
    _value[1] = value._y;
 
    return *this;
}
 
//===========================================================================
// GxF16x4
//===========================================================================
//---------------------------------------------------------------------------
// operator = 
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxF16x4& GxF16x4::operator = (const GxF16x4& value)
{
    _value[0] = value._value[0];
    _value[1] = value._value[1];
    _value[2] = value._value[2];
    _value[3] = value._value[3];
 
    return *this;
}
 
//---------------------------------------------------------------------------
// operator = 
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxF16x4& GxF16x4::operator = (const GxFloat4& value)
{
    _value[0] = value._x;
    _value[1] = value._y;
    _value[2] = value._z;
    _value[3] = value._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// operator = 
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxF16x4& GxF16x4::operator = (const GxVector4& value)
{
    _value[0] = value._x;
    _value[1] = value._y;
    _value[2] = value._z;
    _value[3] = value._w;
 
    return *this;
}
 
//===========================================================================
// ! 8bit[0, 1]正規化小数
//===========================================================================
//---------------------------------------------------------------------------
// デフォルトコンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxU8N::GxU8N(void)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxU8N::GxU8N(f32 valueF32)
{
    _value = f32ToU8N(valueF32).getValueU8();
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxU8N::GxU8N(const GxU8N& valueU8N)
{
    _value = valueU8N._value;
}
 
//---------------------------------------------------------------------------
// 32ビットフロートキャスト
//---------------------------------------------------------------------------
GX_INLINE GxU8N::operator f32() const
{
    return u8NToF32(*this);
}
 
//---------------------------------------------------------------------------
// 32ビットから8ビットの変換
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxU8N GxU8N::f32ToU8N(f32 valueF32)
{
    valueF32 = GxMath::getMin(GxMath::getMax(valueF32, 0.0f), 1.0f);
 
    GxU8N returnValue;
    returnValue.setValueU8(static_cast<u8>(valueF32 * 255.0f));
 
    return returnValue;
}
 
//---------------------------------------------------------------------------
// 8ビットから32ビットの変換
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxU8N::u8NToF32(GxU8N valueU8N)
{
    return valueU8N.getValueU8() / 255.0f;
}
 
//===========================================================================
// 32bit[0, 1]正規化小数4次元ベクトル(8:8:8:8)
//===========================================================================
//---------------------------------------------------------------------------
// operator = 
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxU8Nx4& GxU8Nx4::operator = (const GxU8Nx4& value)
{
    _value[0] = value._value[0];
    _value[1] = value._value[1];
    _value[2] = value._value[2];
    _value[3] = value._value[3];
 
    return *this;
}
 
//---------------------------------------------------------------------------
// operator = 
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxU8Nx4& GxU8Nx4::operator = (const GxFloat4& value)
{
    _value[0] = value._x;
    _value[1] = value._y;
    _value[2] = value._z;
    _value[3] = value._w;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// operator = 
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxU8Nx4& GxU8Nx4::operator = (const GxVector4& value)
{
    _value[0] = value._x;
    _value[1] = value._y;
    _value[2] = value._z;
    _value[3] = value._w;
 
    return *this;
}
 
//===========================================================================
// GxPackedNx3
//===========================================================================
//---------------------------------------------------------------------------
// operator = 
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxPackedNx3& GxPackedNx3::operator = (const GxFloat3& value)
{
    _value  = f32ToS11N(value._x) << SHIFT_X
            | f32ToS11N(value._y) << SHIFT_Y
            | f32ToS10N(value._z) << SHIFT_Z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// operator = 
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxPackedNx3& GxPackedNx3::operator = (const GxVector3& value)
{
    _value  = f32ToS11N(value._x) << SHIFT_X
            | f32ToS11N(value._y) << SHIFT_Y
            | f32ToS10N(value._z) << SHIFT_Z;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 32ビットから10ビットの変換
//---------------------------------------------------------------------------
GX_FORCE_INLINE u32 GxPackedNx3::f32ToS10N(f32 valueF32)
{
    valueF32 = GxMath::getMin(GxMath::getMax(valueF32, -1.0f), 1.0f);
 
    u32 work;
    u32 ret;
 
    if( 0.0f < valueF32 )
    {
        ret = static_cast<u32>(valueF32 * 511.0f);
    }
    else
    {
        work = static_cast<u32>(valueF32 * -512.0f);
        ret = ~work + 0x1;
    }
 
    return ret & 0x3FF;
}
 
//---------------------------------------------------------------------------
// 10ビットから32ビットの変換
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxPackedNx3::s10NTof32(u32 valueS10N)
{
    u32 sine = valueS10N & 0x200;
    valueS10N &= 0x1FF;
 
    f32 ret;
 
    if( !sine )
    {
        ret = valueS10N / 511.0f;
    }
    else
    {
        ret = ((~valueS10N & 0x1FF) + 0x1) / -512.0f;
    }
 
    return ret;
}
 
//---------------------------------------------------------------------------
// 32ビットから11ビットの変換
//---------------------------------------------------------------------------
GX_FORCE_INLINE u32 GxPackedNx3::f32ToS11N(f32 valueF32)
{
    valueF32 = GxMath::getMin(GxMath::getMax(valueF32, -1.0f), 1.0f);
 
    u32 work;
    u32 ret;
 
    if( 0.0f < valueF32 )
    {
        ret = static_cast<u32>(valueF32 * 1023.0f);
    }
    else
    {
        work = static_cast<u32>(valueF32 * -1024.0f);
        ret = ~work + 0x1;
    }
 
    return ret & 0x7FF;
}
 
//---------------------------------------------------------------------------
// 11ビットから32ビットの変換
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxPackedNx3::s11NTof32(u32 valueS10N)
{
    u32 sine = valueS10N & 0x400;
    valueS10N &= 0x3FF;
 
    f32 ret;
 
    if( !sine )
    {
        ret = valueS10N / 1023.0f;
    }
    else
    {
        ret = ((~valueS10N & 0x3FF) + 0x1) / -1024.0f;
    }
 
    return ret;
}
 
//---------------------------------------------------------------------------
// f32で値を取得する
//---------------------------------------------------------------------------
GX_FORCE_INLINE f32 GxPackedNx3::getValueF32(u32 index) const
{
    f32 ret;
 
    switch(index)
    {
    //----------------------
    case 0:     // x成分
    //----------------------
        ret = s11NTof32(_value >> SHIFT_X);
        break;
    //----------------------
    case 1:     // y成分
    //----------------------
        ret = s11NTof32(_value >> SHIFT_Y);
        break;
    //----------------------
    case 2:     // z成分
    //----------------------
        ret = s10NTof32(_value >> SHIFT_Z);
        break;
    //----------------------
    default:    // エラー
    //----------------------
        GX_ASSERT(false, "想定外の成分が指定されました");
        ret = 0.0f;
        break;
    }
 
    return ret;
}
 
//---------------------------------------------------------------------------
// f32で値を設定する
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxPackedNx3::setValueF32(u32 index, f32 value)
{
    switch(index)
    {
    //----------------------
    case 0:     // x成分
    //----------------------
        _value = (_value & (0x000007FF << SHIFT_X)) | (f32ToS11N(value) << SHIFT_X);
        break;
    //----------------------
    case 1:     // y成分
    //----------------------
        _value = (_value & (0x000007FF << SHIFT_Y)) | (f32ToS11N(value) << SHIFT_Y);
        break;
    //----------------------
    case 2:     // z成分
    //----------------------
        _value = (_value & (0xFFC00000 << SHIFT_Z)) | (f32ToS10N(value) << SHIFT_Z);
        break;
    //----------------------
    default:    // エラー
    //----------------------
        GX_ASSERT(false, "想定外の成分が指定されました");
        break;
    }
}
 
//===========================================================================
// GxSize
//===========================================================================
//---------------------------------------------------------------------------
//  コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize::GxSize(s32 width, s32 height)
: _width(width)
, _height(height)
{
}
 
//---------------------------------------------------------------------------
//  コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize::GxSize(const GxRect& rect)
: _width(rect.getWidth())
, _height(rect.getHeight())
{
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize::GxSize(const GxSize& size)
: _width(size._width)
, _height(size._height)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize& GxSize::operator = (const GxSize& size)
{
    _width  = size._width;
    _height = size._height;
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize& GxSize::operator += (s32 scalar)
{
    addScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize& GxSize::operator -= (s32 scalar)
{
    subScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize& GxSize::operator *= (s32 scalar)
{
    mulScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize& GxSize::operator /= (s32 scalar)
{
    divScalar(scalar);
    return *this;
}
 
//---------------------------------------------------------------------------
// サイズ加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize& GxSize::operator += (const GxSize& size)
{
    addSize(size);
    return *this;
}
 
//---------------------------------------------------------------------------
// サイズ減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize& GxSize::operator -= (const GxSize& size)
{
    subSize(size);
    return *this;
}
 
//---------------------------------------------------------------------------
// 論理積
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize& GxSize::operator &= (const GxSize& size)
{
    _width = GxMath::getMin(_width, size._width);
    _height = GxMath::getMin(_height, size._height);
    return *this;
}
 
//---------------------------------------------------------------------------
// 論理和
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxSize& GxSize::operator |= (const GxSize& size)
{
    _width = GxMath::getMax(_width, size._width);
    _height = GxMath::getMax(_height, size._height);
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize operator + (const GxSize& size, s32 scalar)
{
    GxSize result;
    return GxSize::getAddScalar(result, size, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize operator - (const GxSize& size, s32 scalar)
{
    GxSize result;
    return GxSize::getSubScalar(result, size, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize operator * (const GxSize& size, s32 scalar)
{
    GxSize result;
    return GxSize::getMulScalar(result, size, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize operator * (s32 scalar, const GxSize& size)
{
    GxSize result;
    return GxSize::getMulScalar(result, size, scalar);
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize operator / (const GxSize& size, s32 scalar)
{
    GxSize result;
    return GxSize::getDivScalar(result, size, scalar);
}
 
//---------------------------------------------------------------------------
// サイズ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize operator + (const GxSize& size0, const GxSize& size1)
{
    GxSize result;
    return GxSize::getAddSize(result, size0, size1);
}
 
//---------------------------------------------------------------------------
// サイズ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize operator - (const GxSize& size0, const GxSize& size1)
{
    GxSize result;
    return GxSize::getSubSize(result, size0, size1);
}
 
//---------------------------------------------------------------------------
// 論理積
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize operator & (const GxSize& size0, const GxSize& size1)
{
    return GxSize(GxMath::getMin(size0._width, size1._width), GxMath::getMin(size0._height, size1._height));
}
 
//---------------------------------------------------------------------------
// 論理和
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize operator | (const GxSize& size0, const GxSize& size1)
{
    return GxSize(GxMath::getMax(size0._width, size1._width), GxMath::getMax(size0._height, size1._height));
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator == (const GxSize& size0, const GxSize& size1)
{
    return (size0._width == size1._width) && (size0._height == size1._height);
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator != (const GxSize& size0, const GxSize& size1)
{
    return (size0._width != size1._width) || (size0._height != size1._height);
}
 
//---------------------------------------------------------------------------
// スカラ加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::getAddScalar(GxSize& dst, const GxSize& size, s32 scalar)
{
    dst._width  = size._width   + scalar;
    dst._height = size._height  + scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::getSubScalar(GxSize& dst, const GxSize& size, s32 scalar)
{
    dst._width  = size._width   - scalar;
    dst._height = size._height  - scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ乗算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::getMulScalar(GxSize& dst, const GxSize& size, s32 scalar)
{
    dst._width  = size._width   * scalar;
    dst._height = size._height  * scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ除算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::getDivScalar(GxSize& dst, const GxSize& size, s32 scalar)
{
    dst._width  = size._width   / scalar;
    dst._height = size._height  / scalar;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// サイズ加算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::getAddSize(GxSize& dst, const GxSize& size0, const GxSize& size1)
{
    dst._width  = size0._width  + size1._width;
    dst._height = size0._height + size1._height;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// サイズ減算を取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::getSubSize(GxSize& dst, const GxSize& size0, const GxSize& size1)
{
    dst._width  = size0._width  - size1._width;
    dst._height = size0._height - size1._height;
 
    return dst;
}
 
//---------------------------------------------------------------------------
// スカラ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::addScalar(s32 scalar)
{
    _width  += scalar;
    _height += scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::subScalar(s32 scalar)
{
    _width  -= scalar;
    _height -= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ乗算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::mulScalar(s32 scalar)
{
    _width  *= scalar;
    _height *= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// スカラ除算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::divScalar(s32 scalar)
{
    _width  /= scalar;
    _height /= scalar;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// サイズ加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::addSize(const GxSize& size)
{
    _width  += size._width;
    _height += size._height;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// サイズ減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxSize& GxSize::subSize(const GxSize& size)
{
    _width  -= size._width;
    _height -= size._height;
 
    return *this;
}
 
//---------------------------------------------------------------------------
// 内包判定
//---------------------------------------------------------------------------
GX_INLINE b32 GxSize::isIncluding(const GxPoint2& point) const
{
    if( point._x >= 0 && point._y >= 0 && _width - point._x >= 0 && _height - point._y >= 0 )
    {
        return true;
    }
    return false;
}
 
//===========================================================================
// GxPoint2
//===========================================================================
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxPoint2::GxPoint2(s32 x, s32 y)
: _x(x)
, _y(y)
{
}
 
//---------------------------------------------------------------------------
// コンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxPoint2::GxPoint2(const GxVector2& vector )
: _x(static_cast<s32>(vector._x))
, _y(static_cast<s32>(vector._y))
{
}
 
//---------------------------------------------------------------------------
// コピーコンストラクタ
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxPoint2::GxPoint2(const GxPoint2& point)
: _x(point._x)
, _y(point._y)
{
}
 
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxPoint2& GxPoint2::operator = (const GxPoint2& point)
{
    _x = point._x;
    _y = point._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxPoint2& GxPoint2::operator += (const GxPoint2& point)
{
    _x += point._x;
    _y += point._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxPoint2& GxPoint2::operator -= (const GxPoint2& point)
{
    _x -= point._x;
    _y -= point._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 加算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxPoint2& GxPoint2::operator += (const GxSize& size)
{
    _x += size._width;
    _y += size._height;
    return *this;
}
 
//---------------------------------------------------------------------------
// 減算代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxPoint2& GxPoint2::operator -= (const GxSize& size)
{
    _x -= size._width;
    _y -= size._height;
    return *this;
}
 
//---------------------------------------------------------------------------
// 加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxPoint2 operator + (const GxPoint2& point0, const GxPoint2& point1)
{
    return GxPoint2(point0._x + point1._x, point0._y + point1._y);
}
 
//---------------------------------------------------------------------------
// 減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxPoint2 operator - (const GxPoint2& point0, const GxPoint2& point1)
{
    return GxPoint2(point0._x - point1._x, point0._y - point1._y);
}
 
//---------------------------------------------------------------------------
// 加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxPoint2 operator + (const GxPoint2& point, const GxSize& size)
{
    return GxPoint2(point._x + size._width, point._y + size._height);
}
 
//---------------------------------------------------------------------------
// 減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxPoint2 operator - (const GxPoint2& point, const GxSize& size)
{
    return GxPoint2(point._x - size._width, point._y - size._height);
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator == (const GxPoint2& point0, const GxPoint2& point1)
{
    return (point0._x == point1._x) && (point0._y == point1._y);
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator != (const GxPoint2& point0, const GxPoint2& point1)
{
    return (point0._x != point1._x) || (point0._y != point1._y);
}
 
//===========================================================================
// GxRect
//===========================================================================
//---------------------------------------------------------------------------
// 代入
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRect& GxRect::operator = (const GxRect& rect)
{
    _left = rect._left;
    _top = rect._top;
    _right = rect._right;
    _bottom = rect._bottom;
    return *this;
}
 
//---------------------------------------------------------------------------
// 加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRect& GxRect::operator += (const GxRect& rect)
{
    _left += rect._left;
    _top += rect._top;
    _right += rect._right;
    _bottom += rect._bottom;
    return *this;
}
 
//---------------------------------------------------------------------------
// 減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRect& GxRect::operator -= (const GxRect& rect)
{
    _left -= rect._left;
    _top -= rect._top;
    _right -= rect._right;
    _bottom -= rect._bottom;
    return *this;
}
 
//---------------------------------------------------------------------------
// 加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRect& GxRect::operator += (const GxPoint2& point)
{
    _left += point._x;
    _top += point._y;
    _right += point._x;
    _bottom += point._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRect& GxRect::operator -= (const GxPoint2& point)
{
    _left -= point._x;
    _top -= point._y;
    _right -= point._x;
    _bottom -= point._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 論理積
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRect& GxRect::operator &= (const GxRect& rect)
{
    _left = GxMath::getMax(_left, rect._left);
    _top = GxMath::getMax(_top, rect._top);
    _right = GxMath::getMin(_right, rect._right);
    _bottom = GxMath::getMin(_bottom, rect._bottom);
    return *this;
}
 
//---------------------------------------------------------------------------
// 論理和
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRect& GxRect::operator |= (const GxRect& rect)
{
    _left = GxMath::getMin(_left, rect._left);
    _top = GxMath::getMin(_top, rect._top);
    _right = GxMath::getMax(_right, rect._right);
    _bottom = GxMath::getMax(_bottom, rect._bottom);
    return *this;
}
 
//---------------------------------------------------------------------------
// 正
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRect operator + (const GxRect& rect)
{
    return GxRect(rect._left, rect._top, rect._right, rect._bottom);
}
 
//---------------------------------------------------------------------------
// 負
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRect operator - (const GxRect& rect)
{
    return GxRect(-rect._left, -rect._top, -rect._right, -rect._bottom);
}
 
//---------------------------------------------------------------------------
// 加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRect operator + (const GxRect& rect0, const GxRect& rect1)
{
    return GxRect(rect0._left + rect1._left, rect0._top + rect1._top, rect0._right + rect1._right, rect0._bottom + rect1._bottom);
}
 
//---------------------------------------------------------------------------
// 減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRect operator - (const GxRect& rect0, const GxRect& rect1)
{
    return GxRect(rect0._left - rect1._left, rect0._top - rect1._top, rect0._right - rect1._right, rect0._bottom - rect1._bottom);
}
 
//---------------------------------------------------------------------------
// 加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRect operator + (const GxRect& rect, const GxPoint2& point)
{
    return GxRect(rect._left + point._x, rect._top + point._y, rect._right + point._x, rect._bottom + point._y);
}
 
//---------------------------------------------------------------------------
// 減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRect operator - (const GxRect& rect, const GxPoint2& point)
{
    return GxRect(rect._left - point._x, rect._top - point._y, rect._right - point._x, rect._bottom - point._y);
}
 
//---------------------------------------------------------------------------
// 論理積
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRect operator & (const GxRect& rect0, const GxRect& rect1)
{
    return GxRect(GxMath::getMax(rect0._left, rect1._left), GxMath::getMax(rect0._top, rect1._top), GxMath::getMin(rect0._right, rect1._right), GxMath::getMin(rect0._bottom, rect1._bottom));
}
 
//---------------------------------------------------------------------------
// 論理和
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRect operator | (const GxRect& rect0, const GxRect& rect1)
{
    return GxRect(GxMath::getMin(rect0._left, rect1._left), GxMath::getMin(rect0._top, rect1._top), GxMath::getMax(rect0._right, rect1._right), GxMath::getMax(rect0._bottom, rect1._bottom));
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator == (const GxRect& rect0, const GxRect& rect1)
{
    return ( (rect0._left == rect1._left) && (rect0._right == rect1._right) && (rect0._top == rect1._top) && (rect0._bottom == rect1._bottom) );
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator != (const GxRect& rect0, const GxRect& rect1)
{
    return ( (rect0._left != rect1._left) || (rect0._right != rect1._right) || (rect0._top != rect1._top) || (rect0._bottom != rect1._bottom) );
}
 
//---------------------------------------------------------------------------
// 衝突判定
//---------------------------------------------------------------------------
GX_INLINE b32 GxRect::isHit(const GxRect& rect) const
{
    auto andRect = *this & rect;
    if(andRect.getWidth() > 0 && andRect.getHeight() > 0)
    {
        return true;
    }
    return false;
}
 
//---------------------------------------------------------------------------
// 内包判定
//---------------------------------------------------------------------------
GX_INLINE b32 GxRect::isIncluding(const GxRect& rect) const
{
    if( rect._left - _left >= 0 && rect._top - _top >= 0 && _right - rect._right >= 0 && _bottom - rect._bottom >= 0 )
    {
        return true;
    }
    return false;
}
 
//---------------------------------------------------------------------------
// 内包判定
//---------------------------------------------------------------------------
GX_INLINE b32 GxRect::isIncluding(const GxPoint2& point) const
{
    if( point._x - _left >= 0 && point._y - _top >= 0 && _right - point._x >= 0 && _bottom - point._y >= 0 )
    {
        return true;
    }
    return false;
}
 
//---------------------------------------------------------------------------
// サイズ指定
//---------------------------------------------------------------------------
GX_INLINE void GxRect::setSize( const GxSize& size, BASE base )
{
    switch( base )
    {
    case BASE::TOP_LEFT:
        _right = _left + size._width;
        _bottom = _top + size._height;
        break;
    case BASE::TOP_RIGHT:
        _left = _right - size._width;
        _bottom = _top + size._height;
        break;
    case BASE::BOTTOM_LEFT:
        _right = _left + size._width;
        _top = _bottom - size._height;
        break;
    case BASE::BOTTOM_RIGHT:
        _left = _right - size._width;
        _top = _bottom - size._height;
        break;
    }
}
 
//===========================================================================
// GxRectF
//===========================================================================
//---------------------------------------------------------------------------
// 代入(実数)
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRectF& GxRectF::operator = (const GxRectF& rect)
{
    _left = rect._left;
    _top = rect._top;
    _right = rect._right;
    _bottom = rect._bottom;
    return *this;
}
 
//---------------------------------------------------------------------------
// 加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRectF& GxRectF::operator += (const GxRectF& rect)
{
    _left += rect._left;
    _top += rect._top;
    _right += rect._right;
    _bottom += rect._bottom;
    return *this;
}
 
//---------------------------------------------------------------------------
// 減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRectF& GxRectF::operator -= (const GxRectF& rect)
{
    _left -= rect._left;
    _top -= rect._top;
    _right -= rect._right;
    _bottom -= rect._bottom;
    return *this;
}
 
//---------------------------------------------------------------------------
// 加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRectF& GxRectF::operator += (const GxVector2& point)
{
    _left += point._x;
    _top += point._y;
    _right += point._x;
    _bottom += point._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRectF& GxRectF::operator -= (const GxVector2& point)
{
    _left -= point._x;
    _top -= point._y;
    _right -= point._x;
    _bottom -= point._y;
    return *this;
}
 
//---------------------------------------------------------------------------
// 論理積
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRectF& GxRectF::operator &= (const GxRectF& rect)
{
    _left = GxMath::getMax(_left, rect._left);
    _top = GxMath::getMax(_top, rect._top);
    _right = GxMath::getMin(_right, rect._right);
    _bottom = GxMath::getMin(_bottom, rect._bottom);
    return *this;
}
 
//---------------------------------------------------------------------------
// 論理和
//---------------------------------------------------------------------------
GX_FORCE_INLINE GxRectF& GxRectF::operator |= (const GxRectF& rect)
{
    _left = GxMath::getMin(_left, rect._left);
    _top = GxMath::getMin(_top, rect._top);
    _right = GxMath::getMax(_right, rect._right);
    _bottom = GxMath::getMax(_bottom, rect._bottom);
    return *this;
}
 
//---------------------------------------------------------------------------
// 正
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRectF operator + (const GxRectF& rect)
{
    return GxRectF(rect._left, rect._top, rect._right, rect._bottom);
}
 
//---------------------------------------------------------------------------
// 負
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRectF operator - (const GxRectF& rect)
{
    return GxRectF(-rect._left, -rect._top, -rect._right, -rect._bottom);
}
 
//---------------------------------------------------------------------------
// 加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRectF operator + (const GxRectF& rect0, const GxRectF& rect1)
{
    return GxRectF(rect0._left + rect1._left, rect0._top + rect1._top, rect0._right + rect1._right, rect0._bottom + rect1._bottom);
}
 
//---------------------------------------------------------------------------
// 減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRectF operator - (const GxRectF& rect0, const GxRectF& rect1)
{
    return GxRectF(rect0._left - rect1._left, rect0._top - rect1._top, rect0._right - rect1._right, rect0._bottom - rect1._bottom);
}
 
//---------------------------------------------------------------------------
// 加算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRectF operator + (const GxRectF& rect, const GxVector2& point)
{
    return GxRectF(rect._left + point._x, rect._top + point._y, rect._right + point._x, rect._bottom + point._y);
}
 
//---------------------------------------------------------------------------
// 減算
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRectF operator - (const GxRectF& rect, const GxVector2& point)
{
    return GxRectF(rect._left - point._x, rect._top - point._y, rect._right - point._x, rect._bottom - point._y);
}
 
//---------------------------------------------------------------------------
// 論理積
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRectF operator & (const GxRectF& rect0, const GxRectF& rect1)
{
    return GxRectF(GxMath::getMax(rect0._left, rect1._left), GxMath::getMax(rect0._top, rect1._top), GxMath::getMin(rect0._right, rect1._right), GxMath::getMin(rect0._bottom, rect1._bottom));
}
 
//---------------------------------------------------------------------------
// 論理和
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRectF operator | (const GxRectF& rect0, const GxRectF& rect1)
{
    return GxRectF(GxMath::getMin(rect0._left, rect1._left), GxMath::getMin(rect0._top, rect1._top), GxMath::getMax(rect0._right, rect1._right), GxMath::getMax(rect0._bottom, rect1._bottom));
}
 
//---------------------------------------------------------------------------
// 一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator == (const GxRectF& rect0, const GxRectF& rect1)
{
    return ((rect0._left == rect1._left) && (rect0._right == rect1._right) && (rect0._top == rect1._top) && (rect0._bottom == rect1._bottom));
}
 
//---------------------------------------------------------------------------
// 不一致
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 operator != (const GxRectF& rect0, const GxRectF& rect1)
{
    return ((rect0._left != rect1._left) || (rect0._right != rect1._right) || (rect0._top != rect1._top) || (rect0._bottom != rect1._bottom));
}
 
//---------------------------------------------------------------------------
// 衝突判定
//---------------------------------------------------------------------------
GX_INLINE b32 GxRectF::isHit(const GxRectF& rect) const
{
    auto andRect = *this & rect;
    if (andRect.getWidth() > 0 && andRect.getHeight() > 0)
    {
        return true;
    }
    return false;
}
 
//---------------------------------------------------------------------------
// 内包判定
//---------------------------------------------------------------------------
GX_INLINE b32 GxRectF::isIncluding(const GxRectF& rect) const
{
    if (rect._left - _left >= 0 && rect._top - _top >= 0 && _right - rect._right >= 0 && _bottom - rect._bottom >= 0)
    {
        return true;
    }
    return false;
}
 
//---------------------------------------------------------------------------
// 内包判定
//---------------------------------------------------------------------------
GX_INLINE b32 GxRectF::isIncluding(const GxVector2& point) const
{
    if (point._x - _left >= 0 && point._y - _top >= 0 && _right - point._x >= 0 && _bottom - point._y >= 0)
    {
        return true;
    }
    return false;
}
//---------------------------------------------------------------------------
// サイズ指定
//---------------------------------------------------------------------------
GX_INLINE void GxRectF::setSize(const GxSize& size, BASE base)
{
    switch (base)
    {
    case BASE::TOP_LEFT:
        _right = _left + size._width;
        _bottom = _top + size._height;
        break;
    case BASE::TOP_RIGHT:
        _left = _right - size._width;
        _bottom = _top + size._height;
        break;
    case BASE::BOTTOM_LEFT:
        _right = _left + size._width;
        _top = _bottom - size._height;
        break;
    case BASE::BOTTOM_RIGHT:
        _left = _right - size._width;
        _top = _bottom - size._height;
        break;
    }
}
 
//---------------------------------------------------------------------------
// GxRect型を設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxRectF& GxRectF::setGxRect(const GxRect& rect)
{
    _top = static_cast<f32>(rect._top);
    _left = static_cast<f32>(rect._left);
    _right = static_cast<f32>(rect._right);
    _bottom = static_cast<f32>(rect._bottom);
    return *this;
}
 
GX_CORE_NAMESPACE_END()