doc/api/_gx_color_8inl_source.html

//===========================================================================

//===========================================================================


GX_CORE_NAMESPACE_BEGIN()


//===========================================================================

// GxColor

//===========================================================================

//---------------------------------------------------------------------------

// コンストラクタ

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor::GxColor(u32 red, u32 green, u32 blue, u32 alpha)

#if GX_COLOR_RGB_SWAP

    : _blue(blue)

    , _green(green)

    , _red(red)

#else //GX_COLOR_RGB_SWAP

    : _red(red)

    , _green(green)

    , _blue(blue)

#endif // !GX_COLOR_RGB_SWAP

    , _alpha(alpha)

{

}


//---------------------------------------------------------------------------

// コンストラクタ

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor::GxColor(const GxColor color, u32 alpha)

#if GX_COLOR_RGB_SWAP

    : _blue(color._blue)

    , _green(color._green)

    , _red(color._red)

#else //GX_COLOR_RGB_SWAP

    : _red(color._red)

    , _green(color._green)

    , _blue(color._blue)

#endif // !GX_COLOR_RGB_SWAP

    , _alpha(alpha)

{

}


//---------------------------------------------------------------------------

// コンストラクタ

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor::GxColor(const GxColorHDR& color)

#if GX_COLOR_RGB_SWAP

    : _blue(GxMath::getClamp(static_cast<u32>(color._blue * 255), static_cast<u32>(0), static_cast<u32>(255)))

    , _green(GxMath::getClamp(static_cast<u32>(color._green * 255), static_cast<u32>(0), static_cast<u32>(255)))

    , _red(GxMath::getClamp(static_cast<u32>(color._red * 255), static_cast<u32>(0), static_cast<u32>(255)))

#else //GX_COLOR_RGB_SWAP

    : _red(GxMath::getClamp(static_cast<u32>(color._red * 255), static_cast<u32>(0), static_cast<u32>(255)))

    , _green(GxMath::getClamp(static_cast<u32>(color._green * 255), static_cast<u32>(0), static_cast<u32>(255)))

    , _blue(GxMath::getClamp(static_cast<u32>(color._blue * 255), static_cast<u32>(0), static_cast<u32>(255)))

#endif // !GX_COLOR_RGB_SWAP

    , _alpha(GxMath::getClamp(static_cast<u32>(color._alpha * 255), static_cast<u32>(0), static_cast<u32>(255)))

{

}


//---------------------------------------------------------------------------

// コピーコンストラクタ

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor::GxColor(const GxColor& color)

: _color(color._color)

{

}


//---------------------------------------------------------------------------

// 代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor& GxColor::operator = (const GxColor color)

{

    _color = color._color;

    return *this;

}


//---------------------------------------------------------------------------

// スカラ加算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor& GxColor::operator += (u32 scalar)

{

    addScalar(scalar);

    return *this;

}


//---------------------------------------------------------------------------

// スカラ減算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor& GxColor::operator -= (u32 scalar)

{

    subScalar(scalar);

    return *this;

}


//---------------------------------------------------------------------------

// スカラ乗算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor& GxColor::operator *= (f32 scalar)

{

    mulScalar(scalar);

    return *this;

}


//---------------------------------------------------------------------------

// スカラ除算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor& GxColor::operator /= (f32 scalar)

{

    divScalar(scalar);

    return *this;

}


//---------------------------------------------------------------------------

// カラー加算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor& GxColor::operator += (const GxColor color)

{

    addColor(color);

    return *this;

}


//---------------------------------------------------------------------------

// カラー減算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor& GxColor::operator -= (const GxColor color)

{

    subColor(color);

    return *this;

}


//---------------------------------------------------------------------------

// カラー乗算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor& GxColor::operator *= (const GxColor color)

{

    mulColor(color);

    return *this;

}


//---------------------------------------------------------------------------

// スカラ加算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor operator + (const GxColor color, u32 scalar)

{

    GxColor result;

    return GxColor::getAddScalar(result, color, scalar);

}


//---------------------------------------------------------------------------

// スカラ減算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor operator - (const GxColor color, u32 scalar)

{

    GxColor result;

    return GxColor::getSubScalar(result, color, scalar);

}


//---------------------------------------------------------------------------

// スカラ乗算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor operator * (const GxColor color, f32 scalar)

{

    GxColor result;

    return GxColor::getMulScalar(result, color, scalar);

}


//---------------------------------------------------------------------------

// スカラ乗算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor operator * (f32 scalar, const GxColor color)

{

    GxColor result;

    return GxColor::getMulScalar(result, color, scalar);

}


//---------------------------------------------------------------------------

// スカラ除算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor operator / (const GxColor color, f32 scalar)

{

    GxColor result;

    return GxColor::getDivScalar(result, color, scalar);

}


//---------------------------------------------------------------------------

// カラー加算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor operator + (const GxColor color0, const GxColor color1)

{

    GxColor result;

    return GxColor::getAddColor(result, color0, color1);

}


//---------------------------------------------------------------------------

// カラー減算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor operator - (const GxColor color0, const GxColor color1)

{

    GxColor result;

    return GxColor::getSubColor(result, color0, color1);

}


//---------------------------------------------------------------------------

// カラー乗算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor operator * (const GxColor color0, const GxColor color1)

{

    GxColor result;

    return GxColor::getMulColor(result, color0, color1);

}


//---------------------------------------------------------------------------

// 一致

//---------------------------------------------------------------------------


GX_FORCE_INLINE b32 operator == (const GxColor color0, const GxColor color1)

{

    return color0._color == color1._color;

}


//---------------------------------------------------------------------------

// 不一致

//---------------------------------------------------------------------------


GX_FORCE_INLINE b32 operator != (const GxColor color0, const GxColor color1)

{

    return color0._color != color1._color;

}


//---------------------------------------------------------------------------

// スカラ加算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::getAddScalar(GxColor& dst, const GxColor color, u32 scalar)

{

    u32 a0 = color._color & MASK_ALPHA;

#if GX_COLOR_RGB_SWAP

    u32 c0 = color._color;

#else //GX_COLOR_RGB_SWAP

    u32 c0 = color._color >> 8;

#endif // !GX_COLOR_RGB_SWAP

    u32 c1 = (scalar << 16) + (scalar << 8) + scalar;


    u32 c = (((c0 & c1) << 1) + ((c0 ^ c1) & 0x00FEFEFE)) & 0x01010100;

    c = ((c >> 8) + 0x007F7F7F) ^ 0x007F7F7F;


#if GX_COLOR_RGB_SWAP

    dst._color = (c0 + c1 - c) | c | a0;

#else //GX_COLOR_RGB_SWAP

    dst._color = (((c0 + c1 - c) | c) << 8) | a0;

#endif // !GX_COLOR_RGB_SWAP


    return dst;

}


//---------------------------------------------------------------------------

// スカラ減算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::getSubScalar(GxColor& dst, const GxColor color, u32 scalar)

{

    u32 a0 = color._color & MASK_ALPHA;

#if GX_COLOR_RGB_SWAP

    u32 c0 = color._color;

#else //GX_COLOR_RGB_SWAP

    u32 c0 = color._color >> 8;

#endif // !GX_COLOR_RGB_SWAP

    u32 c1 = (scalar << 16) + (scalar << 8) + scalar;


    u32 c = (((~c0 & c1) << 1) + ((~c0 ^ c1) & 0x00FEFEFE)) & 0x01010100;

    c = ((c >> 8) + 0x007F7F7F) ^ 0x007F7F7F;


#if GX_COLOR_RGB_SWAP

    dst._color = (c0 | c) - (c1 | c) | a0;

#else //GX_COLOR_RGB_SWAP

    dst._color = (((c0 | c) - (c1 | c)) << 8) | a0;

#endif // !GX_COLOR_RGB_SWAP


    return dst;

}


//---------------------------------------------------------------------------

// スカラ乗算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::getMulScalar(GxColor& dst, const GxColor color, f32 scalar)

{

    dst._red    = GxMath::getMax(GxMath::getMin(static_cast<u32>(color._red     * scalar), static_cast<u32>(255)), static_cast<u32>(0));

    dst._green  = GxMath::getMax(GxMath::getMin(static_cast<u32>(color._green   * scalar), static_cast<u32>(255)), static_cast<u32>(0));

    dst._blue   = GxMath::getMax(GxMath::getMin(static_cast<u32>(color._blue    * scalar), static_cast<u32>(255)), static_cast<u32>(0));

    dst._alpha  = color._alpha;


    return dst;

}


//---------------------------------------------------------------------------

// スカラ除算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::getDivScalar(GxColor& dst, const GxColor color, f32 scalar)

{

    f32 invScalar = 1.0f / scalar;


    dst._red    = GxMath::getMax(GxMath::getMin(static_cast<u32>(color._red     * invScalar), static_cast<u32>(255)), static_cast<u32>(0));

    dst._green  = GxMath::getMax(GxMath::getMin(static_cast<u32>(color._green   * invScalar), static_cast<u32>(255)), static_cast<u32>(0));

    dst._blue   = GxMath::getMax(GxMath::getMin(static_cast<u32>(color._blue    * invScalar), static_cast<u32>(255)), static_cast<u32>(0));

    dst._alpha  = color._alpha;


    return dst;

}


//---------------------------------------------------------------------------

// カラー加算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::getAddColor(GxColor& dst, const GxColor color0, const GxColor color1)

{

    u32 a0 = color0._color & MASK_ALPHA;

#if GX_COLOR_RGB_SWAP

    u32 c0 = color0._color;

    u32 c1 = color1._color;

#else //GX_COLOR_RGB_SWAP

    u32 c0 = color0._color >> 8;

    u32 c1 = color1._color >> 8;

#endif // !GX_COLOR_RGB_SWAP


    u32 c = (((c0 & c1) << 1) + ((c0 ^ c1) & 0x00FEFEFE)) & 0x01010100;

    c = ((c >> 8) + 0x007F7F7F) ^ 0x007F7F7F;


#if GX_COLOR_RGB_SWAP

    dst._color = (c0 + c1 - c) | c | a0;

#else //GX_COLOR_RGB_SWAP

    dst._color = (((c0 + c1 - c) | c) << 8) | a0;

#endif // !GX_COLOR_RGB_SWAP


    return dst;

}


//---------------------------------------------------------------------------

// カラー減算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::getSubColor(GxColor& dst, const GxColor color0, const GxColor color1)

{

    u32 a0 = color0._color & MASK_ALPHA;

#if GX_COLOR_RGB_SWAP

    u32 c0 = color0._color;

    u32 c1 = color1._color;

#else //GX_COLOR_RGB_SWAP

    u32 c0 = color0._color >> 8;

    u32 c1 = color1._color >> 8;

#endif // !GX_COLOR_RGB_SWAP


    u32 c = (((~c0 & c1) << 1) + ((~c0 ^ c1) & 0x00FEFEFE)) & 0x01010100;

    c = ((c >> 8) + 0x007F7F7F) ^ 0x007F7F7F;


#if GX_COLOR_RGB_SWAP

    dst._color = (c0 | c) - (c1 | c) | a0;

#else //GX_COLOR_RGB_SWAP

    dst._color = (((c0 | c) - (c1 | c)) << 8) | a0;

#endif // !GX_COLOR_RGB_SWAP


    return dst;

}


//---------------------------------------------------------------------------

// カラー乗算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::getMulColor(GxColor& dst, const GxColor color0, const GxColor color1)

{

    dst._red    = (color0._red      * color1._red   + 255) >> 8;

    dst._green  = (color0._green    * color1._green + 255) >> 8;

    dst._blue   = (color0._blue     * color1._blue  + 255) >> 8;

    dst._alpha  = (color0._alpha    * color1._alpha + 255) >> 8;


    return dst;

}


//---------------------------------------------------------------------------

// 補間値を取得(互換用)

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor GxColor::getLerp(const GxColor color0, const GxColor color1, f32 t)

{

    GxColor result;

    u32 ut1 = static_cast<u32>(256 * t);

    u32 ut0 = 256 - ut1;


    u32 c00 =  color0._color & 0x00FF00FF;

    u32 c01 = (color0._color & 0xFF00FF00) >> 8;

    u32 c10 =  color1._color & 0x00FF00FF;

    u32 c11 = (color1._color & 0xFF00FF00) >> 8;


    c00 = ((c00 * ut0 + c10 * ut1) & 0xFF00FF00) >> 8;

    c01 =  (c01 * ut0 + c11 * ut1) & 0xFF00FF00;


    result._color = c00 | c01;

    return result;

}


//---------------------------------------------------------------------------

// 補間値を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::getLerp(GxColor& dst, const GxColor color0, const GxColor color1, f32 t)

{

    u32 ut1 = static_cast<u32>(256 * t);

    u32 ut0 = 256 - ut1;


    u32 c00 =  color0._color & 0x00FF00FF;

    u32 c01 = (color0._color & 0xFF00FF00) >> 8;

    u32 c10 =  color1._color & 0x00FF00FF;

    u32 c11 = (color1._color & 0xFF00FF00) >> 8;


    c00 = ((c00 * ut0 + c10 * ut1) & 0xFF00FF00) >> 8;

    c01 =  (c01 * ut0 + c11 * ut1) & 0xFF00FF00;


    dst._color = c00 | c01;

    return dst;

}


//---------------------------------------------------------------------------

// スカラ加算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::addScalar(u32 scalar)

{

    u32 a0 = _color & MASK_ALPHA;

#if GX_COLOR_RGB_SWAP

    u32 c0 = _color;

#else //GX_COLOR_RGB_SWAP

    u32 c0 = _color >> 8;

#endif // !GX_COLOR_RGB_SWAP

    u32 c1 = (scalar << 16) + (scalar << 8) + scalar;


    u32 c = (((c0 & c1) << 1) + ((c0 ^ c1) & 0x00FEFEFE)) & 0x01010100;

    c = ((c >> 8) + 0x007F7F7F) ^ 0x007F7F7F;


#if GX_COLOR_RGB_SWAP

    _color = (c0 + c1 - c) | c | a0;

#else //GX_COLOR_RGB_SWAP

    _color = (((c0 + c1 - c) | c) << 8) | a0;

#endif // !GX_COLOR_RGB_SWAP


    return *this;

}


//---------------------------------------------------------------------------

// スカラ減算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::subScalar(u32 scalar)

{

    u32 a0 = _color & MASK_ALPHA;

#if GX_COLOR_RGB_SWAP

    u32 c0 = _color;

#else //GX_COLOR_RGB_SWAP

    u32 c0 = _color >> 8;

#endif // !GX_COLOR_RGB_SWAP

    u32 c1 = (scalar << 16) + (scalar << 8) + scalar;


    u32 c = (((~c0 & c1) << 1) + ((~c0 ^ c1) & 0x00FEFEFE)) & 0x01010100;

    c = ((c >> 8) + 0x007F7F7F) ^ 0x007F7F7F;


#if GX_COLOR_RGB_SWAP

    _color = (c0 | c) - (c1 | c) | a0;

#else //GX_COLOR_RGB_SWAP

    _color = (((c0 | c) - (c1 | c)) << 8) | a0;

#endif // !GX_COLOR_RGB_SWAP


    return *this;

}


//---------------------------------------------------------------------------

// スカラ乗算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::mulScalar(f32 scalar)

{

    _red    = GxMath::getMax(GxMath::getMin(static_cast<u32>(_red   * scalar), static_cast<u32>(255)), static_cast<u32>(0));

    _green  = GxMath::getMax(GxMath::getMin(static_cast<u32>(_green * scalar), static_cast<u32>(255)), static_cast<u32>(0));

    _blue   = GxMath::getMax(GxMath::getMin(static_cast<u32>(_blue  * scalar), static_cast<u32>(255)), static_cast<u32>(0));


    return *this;

}


//---------------------------------------------------------------------------

// スカラ除算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::divScalar(f32 scalar)

{

    f32 invScalar = 1.0f / scalar;


    _red    = GxMath::getMax(GxMath::getMin(static_cast<u32>(_red   * invScalar), static_cast<u32>(255)), static_cast<u32>(0));

    _green  = GxMath::getMax(GxMath::getMin(static_cast<u32>(_green * invScalar), static_cast<u32>(255)), static_cast<u32>(0));

    _blue   = GxMath::getMax(GxMath::getMin(static_cast<u32>(_blue  * invScalar), static_cast<u32>(255)), static_cast<u32>(0));


    return *this;

}


//---------------------------------------------------------------------------

// カラー加算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::addColor(const GxColor color)

{

    u32 a0 = _color & MASK_ALPHA;

#if GX_COLOR_RGB_SWAP

    u32 c0 = _color;

    u32 c1 = color._color;

#else //GX_COLOR_RGB_SWAP

    u32 c0 = _color >> 8;

    u32 c1 = color._color >> 8;

#endif // !GX_COLOR_RGB_SWAP


    u32 c = (((c0 & c1) << 1) + ((c0 ^ c1) & 0x00FEFEFE)) & 0x01010100;

    c = ((c >> 8) + 0x007F7F7F) ^ 0x007F7F7F;


#if GX_COLOR_RGB_SWAP

    _color = (c0 + c1 - c) | c | a0;

#else //GX_COLOR_RGB_SWAP

    _color = (((c0 + c1 - c) | c) << 8) | a0;

#endif // !GX_COLOR_RGB_SWAP


    return *this;

}


//---------------------------------------------------------------------------

// カラー減算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::subColor(const GxColor color)

{

    u32 a0 = _color & MASK_ALPHA;

#if GX_COLOR_RGB_SWAP

    u32 c0 = _color;

    u32 c1 = color._color;

#else //GX_COLOR_RGB_SWAP

    u32 c0 = _color >> 8;

    u32 c1 = color._color >> 8;

#endif // !GX_COLOR_RGB_SWAP


    u32 c = (((~c0 & c1) << 1) + ((~c0 ^ c1) & 0x00FEFEFE)) & 0x01010100;

    c = ((c >> 8) + 0x007F7F7F) ^ 0x007F7F7F;


#if GX_COLOR_RGB_SWAP

    _color = (c0 | c) - (c1 | c) | a0;

#else //GX_COLOR_RGB_SWAP

    _color = (((c0 | c) - (c1 | c)) << 8) | a0;

#endif // !GX_COLOR_RGB_SWAP


    return *this;

}


//---------------------------------------------------------------------------

// カラー乗算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColor& GxColor::mulColor(const GxColor color)

{

    _red    = (_red     * color._red    + 255) >> 8;

    _green  = (_green   * color._green  + 255) >> 8;

    _blue   = (_blue    * color._blue   + 255) >> 8;

    _alpha  = (_alpha   * color._alpha  + 255) >> 8;


    return *this;

}


//---------------------------------------------------------------------------

// PS3メモリ配置の色をWindowsメモリ配置の色に変換

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor GxColor::convertPs3ToWindows(const GxColor ps3Color)

{

    // windowsメモリ配置では ARGB

    // ps3    メモリ配置では RGBA

    GxColor windowsColor;


#if GX_BIG_ENDIAN

    // ビッグエンディアンでは RGBA -> ARGB

    windowsColor._color = (ps3Color._color << 24)                   // A

                        | (ps3Color._color >>  8);                  //  RGB

#else

    // リトルエンディアンでは ABGR -> ARGB

    windowsColor._color = (ps3Color._color & 0xFF00FF00)            // A G

                        | ((ps3Color._color & 0x000000FF) << 16)    //  R

                        | ((ps3Color._color & 0x00FF0000) >> 16);   //    B

#endif //GX_LITTLE_ENDIAN


    return windowsColor;

}


//---------------------------------------------------------------------------

// Windowsメモリ配置の色をPS3メモリ配置の色に変換

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColor GxColor::convertWindowsToPs3(const GxColor windowsColor)

{

    // windowsメモリ配置では ARGB

    // ps3    メモリ配置では RGBA

    GxColor ps3Color;


#if GX_BIG_ENDIAN

    // ビッグエンディアンでは ARGB -> RGBA

    ps3Color._color = (windowsColor._color >> 24)                   //    A

                    | (windowsColor._color <<  8);                  // RGB

#else

    // リトルエンディアンでは ARGB -> ABGR

    ps3Color._color = (windowsColor._color & 0xFF00FF00)            // A G

                    | ((windowsColor._color & 0x000000FF) << 16)    //  B

                    | ((windowsColor._color & 0x00FF0000) >> 16);   //    R

#endif //GX_LITTLE_ENDIAN


    return ps3Color;

}


//===========================================================================

// GxColorHDR

//===========================================================================

//---------------------------------------------------------------------------

// コンストラクタ

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR::GxColorHDR(f32 red, f32 green, f32 blue, f32 alpha)

: _red(red)

, _green(green)

, _blue(blue)

, _alpha(alpha)

{

}


//---------------------------------------------------------------------------

// コンストラクタ

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR::GxColorHDR(const GxColor color)

: _red(color._red / 255.0f)

, _green(color._green / 255.0f)

, _blue(color._blue / 255.0f)

, _alpha(color._alpha / 255.0f)

{

}


//---------------------------------------------------------------------------

// コピーコンストラクタ

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR::GxColorHDR(const GxColorHDR& color)

: _red(color._red)

, _green(color._green)

, _blue(color._blue)

, _alpha(color._alpha)

{

}


//---------------------------------------------------------------------------

// 代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR& GxColorHDR::operator = (const GxColorHDR& color)

{

    _red    = color._red;

    _green  = color._green;

    _blue   = color._blue;

    _alpha  = color._alpha;

    return *this;

}


//---------------------------------------------------------------------------

// スカラ加算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR& GxColorHDR::operator += (f32 scalar)

{

    addScalar(scalar);

    return *this;

}


//---------------------------------------------------------------------------

// スカラ減算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR& GxColorHDR::operator -= (f32 scalar)

{

    subScalar(scalar);

    return *this;

}


//---------------------------------------------------------------------------

// スカラ乗算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR& GxColorHDR::operator *= (f32 scalar)

{

    mulScalar(scalar);

    return *this;

}


//---------------------------------------------------------------------------

// スカラ除算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR& GxColorHDR::operator /= (f32 scalar)

{

    divScalar(scalar);

    return *this;

}


//---------------------------------------------------------------------------

// カラー加算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR& GxColorHDR::operator += (const GxColorHDR& color)

{

    addColor(color);

    return *this;

}


//---------------------------------------------------------------------------

// カラー減算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR& GxColorHDR::operator -= (const GxColorHDR& color)

{

    subColor(color);

    return *this;

}


//---------------------------------------------------------------------------

// カラー乗算代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR& GxColorHDR::operator *= (const GxColorHDR& color)

{

    mulColor(color);

    return *this;

}


//---------------------------------------------------------------------------

// スカラ加算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR operator + (const GxColorHDR& color, f32 scalar)

{

    GxColorHDR result;

    return GxColorHDR::getAddScalar(result, color, scalar);

}


//---------------------------------------------------------------------------

// スカラ減算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR operator - (const GxColorHDR& color, f32 scalar)

{

    GxColorHDR result;

    return GxColorHDR::getSubScalar(result, color, scalar);

}


//---------------------------------------------------------------------------

// スカラ乗算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR operator * (const GxColorHDR& color, f32 scalar)

{

    GxColorHDR result;

    return GxColorHDR::getMulScalar(result, color, scalar);

}


//---------------------------------------------------------------------------

// スカラ乗算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR operator * (f32 scalar, const GxColorHDR& color)

{

    GxColorHDR result;

    return GxColorHDR::getMulScalar(result, color, scalar);

}


//---------------------------------------------------------------------------

// スカラ除算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR operator / (const GxColorHDR& color, f32 scalar)

{

    GxColorHDR result;

    return GxColorHDR::getDivScalar(result, color, scalar);

}


//---------------------------------------------------------------------------

// カラー加算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR operator + (const GxColorHDR& color0, const GxColorHDR& color1)

{

    GxColorHDR result;

    return GxColorHDR::getAddColor(result, color0, color1);

}


//---------------------------------------------------------------------------

// カラー減算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR operator - (const GxColorHDR& color0, const GxColorHDR& color1)

{

    GxColorHDR result;

    return GxColorHDR::getSubColor(result, color0, color1);

}


//---------------------------------------------------------------------------

// カラー乗算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR operator * (const GxColorHDR& color0, const GxColorHDR& color1)

{

    GxColorHDR result;

    return GxColorHDR::getMulColor(result, color0, color1);

}


//---------------------------------------------------------------------------

// 一致

//---------------------------------------------------------------------------


GX_FORCE_INLINE b32 operator == (const GxColorHDR& color0, const GxColorHDR& color1)

{

    return (color0._red == color1._red) && (color0._green == color1._green) && (color0._blue == color1._blue) && (color0._alpha == color1._alpha);

}


//---------------------------------------------------------------------------

// 不一致

//---------------------------------------------------------------------------


GX_FORCE_INLINE b32 operator != (const GxColorHDR& color0, const GxColorHDR& color1)

{

    return (color0._red != color1._red) || (color0._green != color1._green) || (color0._blue != color1._blue) || (color0._alpha != color1._alpha);

}


//---------------------------------------------------------------------------

// スカラ加算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::getAddScalar(GxColorHDR& dst, const GxColorHDR& color, f32 scalar)

{

    dst._red    = color._red    + scalar;

    dst._green  = color._green  + scalar;

    dst._blue   = color._blue   + scalar;

    dst._alpha  = color._alpha;


    return dst;

}


//---------------------------------------------------------------------------

// スカラ減算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::getSubScalar(GxColorHDR& dst, const GxColorHDR& color, f32 scalar)

{

    dst._red    = color._red    - scalar;

    dst._green  = color._green  - scalar;

    dst._blue   = color._blue   - scalar;

    dst._alpha  = color._alpha;


    return dst;

}


//---------------------------------------------------------------------------

// スカラ乗算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::getMulScalar(GxColorHDR& dst, const GxColorHDR& color, f32 scalar)

{

    dst._red    = color._red    * scalar;

    dst._green  = color._green  * scalar;

    dst._blue   = color._blue   * scalar;

    dst._alpha  = color._alpha;


    return dst;

}


//---------------------------------------------------------------------------

// スカラ除算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::getDivScalar(GxColorHDR& dst, const GxColorHDR& color, f32 scalar)

{

    f32 invScalar = 1.0f / scalar;


    dst._red    = color._red    * invScalar;

    dst._green  = color._green  * invScalar;

    dst._blue   = color._blue   * invScalar;

    dst._alpha  = color._alpha;


    return dst;

}


//---------------------------------------------------------------------------

// カラー加算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::getAddColor(GxColorHDR& dst, const GxColorHDR& color0, const GxColorHDR& color1)

{

    dst._red    = color0._red   + color1._red;

    dst._green  = color0._green + color1._green;

    dst._blue   = color0._blue  + color1._blue;

    dst._alpha  = color0._alpha;


    return dst;

}


//---------------------------------------------------------------------------

// カラー減算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::getSubColor(GxColorHDR& dst, const GxColorHDR& color0, const GxColorHDR& color1)

{

    dst._red    = color0._red   - color1._red;

    dst._green  = color0._green - color1._green;

    dst._blue   = color0._blue  - color1._blue;

    dst._alpha  = color0._alpha;


    return dst;

}


//---------------------------------------------------------------------------

// カラー乗算を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::getMulColor(GxColorHDR& dst, const GxColorHDR& color0, const GxColorHDR& color1)

{

    dst._red    = color0._red   * color1._red;

    dst._green  = color0._green * color1._green;

    dst._blue   = color0._blue  * color1._blue;

    dst._alpha  = color0._alpha * color1._alpha;


    return dst;

}


//---------------------------------------------------------------------------

// 補間値を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::getLerp(GxColorHDR& dst, const GxColorHDR& color0, const GxColorHDR& color1, f32 t)

{

    dst._red    = color0._red   + (color1._red      - color0._red   ) * t;

    dst._green  = color0._green + (color1._green    - color0._green ) * t;

    dst._blue   = color0._blue  + (color1._blue     - color0._blue  ) * t;

    dst._alpha  = color0._alpha + (color1._alpha    - color0._alpha ) * t;


    return dst;

}


//---------------------------------------------------------------------------

// スカラ加算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::addScalar(f32 scalar)

{

    _red    += scalar;

    _green  += scalar;

    _blue   += scalar;


    return *this;

}


//---------------------------------------------------------------------------

// スカラ減算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::subScalar(f32 scalar)

{

    _red    -= scalar;

    _green  -= scalar;

    _blue   -= scalar;


    return *this;

}


//---------------------------------------------------------------------------

// スカラ乗算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::mulScalar(f32 scalar)

{

    _red    *= scalar;

    _green  *= scalar;

    _blue   *= scalar;


    return *this;

}


//---------------------------------------------------------------------------

// スカラ除算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::divScalar(f32 scalar)

{

    f32 invScalar = 1.0f / scalar;


    _red    *= invScalar;

    _green  *= invScalar;

    _blue   *= invScalar;


    return *this;

}


//---------------------------------------------------------------------------

// カラー加算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::addColor(const GxColorHDR& color)

{

    _red    += color._red;

    _green  += color._green;

    _blue   += color._blue;


    return *this;

}


//---------------------------------------------------------------------------

// カラー減算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::subColor(const GxColorHDR& color)

{

    _red    -= color._red;

    _green  -= color._green;

    _blue   -= color._blue;


    return *this;

}


//---------------------------------------------------------------------------

// カラー乗算

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHDR& GxColorHDR::mulColor(const GxColorHDR& color)

{

    _red    *= color._red;

    _green  *= color._green;

    _blue   *= color._blue;

    _alpha  *= color._alpha;


    return *this;

}


//===========================================================================

// GxColorHSV

//===========================================================================

//---------------------------------------------------------------------------

// コンストラクタ

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHSV::GxColorHSV(f32 hue, f32 saturation, f32 value, f32 alpha)

: _hue(hue)

, _saturation(saturation)

, _value(value)

, _alpha(alpha)

{

}


//---------------------------------------------------------------------------

// コンストラクタ

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHSV::GxColorHSV(const GxColorHDR& color)

{

    setRgb(color);

}


//---------------------------------------------------------------------------

// コピーコンストラクタ

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHSV::GxColorHSV(const GxColorHSV& color)

: _hue(color._hue)

, _saturation(color._saturation)

, _value(color._value)

, _alpha(color._alpha)

{

}


//---------------------------------------------------------------------------

// 代入

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHSV& GxColorHSV::operator = (const GxColorHSV& color)

{

    _hue        = color._hue;

    _saturation = color._saturation;

    _value      = color._value;

    _alpha      = color._alpha;

    return *this;

}


//---------------------------------------------------------------------------

// 一致

//---------------------------------------------------------------------------


GX_FORCE_INLINE b32 operator == (const GxColorHSV& color0, const GxColorHSV& color1)

{

    return (color0._hue == color1._hue) && (color0._saturation == color1._saturation) && (color0._value == color1._value) && (color0._alpha == color1._alpha);

}


//---------------------------------------------------------------------------

// 不一致

//---------------------------------------------------------------------------


GX_FORCE_INLINE b32 operator != (const GxColorHSV& color0, const GxColorHSV& color1)

{

    return (color0._hue != color1._hue) || (color0._saturation != color1._saturation) || (color0._value != color1._value) || (color0._alpha != color1._alpha);

}


//---------------------------------------------------------------------------

// RGBを設定

//---------------------------------------------------------------------------


GX_FORCE_INLINE void GxColorHSV::setRgb(const GxColorHDR& color)

{

    rgb2hsv(color, *this);

}


//---------------------------------------------------------------------------

// RGBを取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE GxColorHDR GxColorHSV::getRgb(void) const

{

    GxColorHDR rgb;

    hsv2rgb(*this, rgb);


    return rgb;

}


//---------------------------------------------------------------------------

// 反転色(色相だけ)を取得

//---------------------------------------------------------------------------


GX_FORCE_INLINE const GxColorHSV& GxColorHSV::getInvertHue(GxColorHSV& dst, const GxColorHSV& color)

{

    dst._hue        = color._hue + 180.0f;

    dst._saturation = color._saturation;

    dst._value      = color._value;

    dst._alpha      = color._alpha;


    if (360.0f < dst._hue)

    {

        dst._hue -= 360.0f;

    }

    return dst;

}


GX_CORE_NAMESPACE_END()

operator*
GX_FORCE_INLINE const GxColor operator*(const GxColor color, f32 scalar)
Definition GxColor.inl:202

operator==
GX_FORCE_INLINE b32 operator==(const GxColor color0, const GxColor color1)
Definition GxColor.inl:274

operator/
GX_FORCE_INLINE const GxColor operator/(const GxColor color, f32 scalar)
Definition GxColor.inl:226

operator+
GX_FORCE_INLINE const GxColor operator+(const GxColor color, u32 scalar)
Definition GxColor.inl:178

operator!=
GX_FORCE_INLINE b32 operator!=(const GxColor color0, const GxColor color1)
Definition GxColor.inl:285

operator-
GX_FORCE_INLINE const GxColor operator-(const GxColor color, u32 scalar)
Definition GxColor.inl:190

GxMath::getClamp
static GX_FORCE_INLINE T getClamp(const T value, const T min, const T max)
最小値・最大値で切り落とす
Definition GxMath.h:170

GxMath::getMax
static GX_FORCE_INLINE T getMax(const T value0, const T value1)
大きいほうを取得
Definition GxMath.h:174

GxMath::getMin
static GX_FORCE_INLINE T getMin(const T value0, const T value1)
小さいほうを取得
Definition GxMath.h:172

GxColorHDR
色(HDR)
Definition GxColor.h:241

GxColorHDR::getDivScalar
static GX_FORCE_INLINE const GxColorHDR & getDivScalar(GxColorHDR &dst, const GxColorHDR &color, f32 scalar)
スカラ除算を取得
Definition GxColor.inl:1027

GxColorHDR::subColor
GX_FORCE_INLINE const GxColorHDR & subColor(const GxColorHDR &color)
カラー減算
Definition GxColor.inl:1185

GxColorHDR::getSubScalar
static GX_FORCE_INLINE const GxColorHDR & getSubScalar(GxColorHDR &dst, const GxColorHDR &color, f32 scalar)
スカラ減算を取得
Definition GxColor.inl:993

GxColorHDR::getSubColor
static GX_FORCE_INLINE const GxColorHDR & getSubColor(GxColorHDR &dst, const GxColorHDR &color0, const GxColorHDR &color1)
カラー減算を取得
Definition GxColor.inl:1063

GxColorHDR::mulScalar
GX_FORCE_INLINE const GxColorHDR & mulScalar(f32 scalar)
スカラ乗算
Definition GxColor.inl:1141

GxColorHDR::operator-=
GX_FORCE_INLINE GxColorHDR & operator-=(f32 scalar)
スカラ減算代入
Definition GxColor.inl:790

GxColorHDR::addColor
GX_FORCE_INLINE const GxColorHDR & addColor(const GxColorHDR &color)
カラー加算
Definition GxColor.inl:1171

GxColorHDR::operator/=
GX_FORCE_INLINE GxColorHDR & operator/=(f32 scalar)
スカラ除算代入
Definition GxColor.inl:812

GxColorHDR::operator*=
GX_FORCE_INLINE GxColorHDR & operator*=(f32 scalar)
スカラ乗算代入
Definition GxColor.inl:801

GxColorHDR::divScalar
GX_FORCE_INLINE const GxColorHDR & divScalar(f32 scalar)
スカラ除算
Definition GxColor.inl:1155

GxColorHDR::operator=
GX_FORCE_INLINE GxColorHDR & operator=(const GxColorHDR &color)
代入
Definition GxColor.inl:765

GxColorHDR::getAddColor
static GX_FORCE_INLINE const GxColorHDR & getAddColor(GxColorHDR &dst, const GxColorHDR &color0, const GxColorHDR &color1)
カラー加算を取得
Definition GxColor.inl:1046

GxColorHDR::getAddScalar
static GX_FORCE_INLINE const GxColorHDR & getAddScalar(GxColorHDR &dst, const GxColorHDR &color, f32 scalar)
スカラ加算を取得
Definition GxColor.inl:976

GxColorHDR::_green
f32 _green
緑(0.0f～1.0f)
Definition GxColor.h:362

GxColorHDR::_blue
f32 _blue
青(0.0f～1.0f)
Definition GxColor.h:363

GxColorHDR::getLerp
static GX_FORCE_INLINE const GxColorHDR & getLerp(GxColorHDR &dst, const GxColorHDR &color0, const GxColorHDR &color1, f32 t)
補間値を取得
Definition GxColor.inl:1098

GxColorHDR::addScalar
GX_FORCE_INLINE const GxColorHDR & addScalar(f32 scalar)
スカラ加算
Definition GxColor.inl:1113

GxColorHDR::GxColorHDR
GxColorHDR(void)
デフォルトコンストラクタ
Definition GxColor.h:256

GxColorHDR::_red
f32 _red
赤(0.0f～1.0f)
Definition GxColor.h:361

GxColorHDR::subScalar
GX_FORCE_INLINE const GxColorHDR & subScalar(f32 scalar)
スカラ減算
Definition GxColor.inl:1127

GxColorHDR::getMulScalar
static GX_FORCE_INLINE const GxColorHDR & getMulScalar(GxColorHDR &dst, const GxColorHDR &color, f32 scalar)
スカラ乗算を取得
Definition GxColor.inl:1010

GxColorHDR::_alpha
f32 _alpha
不透明度(0.0f～1.0f)
Definition GxColor.h:364

GxColorHDR::mulColor
GX_FORCE_INLINE const GxColorHDR & mulColor(const GxColorHDR &color)
カラー乗算
Definition GxColor.inl:1199

GxColorHDR::getMulColor
static GX_FORCE_INLINE const GxColorHDR & getMulColor(GxColorHDR &dst, const GxColorHDR &color0, const GxColorHDR &color1)
カラー乗算を取得
Definition GxColor.inl:1080

GxColorHDR::operator+=
GX_FORCE_INLINE GxColorHDR & operator+=(f32 scalar)
スカラ加算代入
Definition GxColor.inl:779

GxColorHSV
色(HSV)
Definition GxColor.h:373

GxColorHSV::setRgb
GX_FORCE_INLINE void setRgb(const GxColorHDR &color)
RGBを設定
Definition GxColor.inl:1288

GxColorHSV::_value
f32 _value
明度(0.0f～1.0f)
Definition GxColor.h:443

GxColorHSV::GxColorHSV
GxColorHSV(void)
デフォルトコンストラクタ
Definition GxColor.h:388

GxColorHSV::operator=
GX_FORCE_INLINE GxColorHSV & operator=(const GxColorHSV &color)
代入
Definition GxColor.inl:1253

GxColorHSV::rgb2hsv
static void rgb2hsv(const GxColorHDR &rgb, GxColorHSV &hsv)
RGBをHSVに変換
Definition GxColor.cpp:221

GxColorHSV::_hue
f32 _hue
色相(0.0f～360.0f)
Definition GxColor.h:441

GxColorHSV::hsv2rgb
static void hsv2rgb(const GxColorHSV &hsv, GxColorHDR &rgb)
HSVをRGBに変換
Definition GxColor.cpp:159

GxColorHSV::getRgb
GX_FORCE_INLINE GxColorHDR getRgb(void) const
RGBを取得
Definition GxColor.inl:1298

GxColorHSV::_alpha
f32 _alpha
不透明度(0.0f～1.0f)
Definition GxColor.h:444

GxColorHSV::getInvertHue
static GX_FORCE_INLINE const GxColorHSV & getInvertHue(GxColorHSV &dst, const GxColorHSV &color)
反転色(色相だけ)を取得
Definition GxColor.inl:1312

GxColorHSV::_saturation
f32 _saturation
彩度(0.0f～1.0f)
Definition GxColor.h:442

GxColor
色
Definition GxColor.h:21

GxColor::getDivScalar
static GX_FORCE_INLINE const GxColor & getDivScalar(GxColor &dst, const GxColor color, f32 scalar)
スカラ除算を取得
Definition GxColor.inl:372

GxColor::convertWindowsToPs3
static GX_FORCE_INLINE GxColor convertWindowsToPs3(const GxColor windowsColor)
Windowsメモリ配置の色をPS3メモリ配置の色に変換
Definition GxColor.inl:698

GxColor::operator/=
GX_FORCE_INLINE GxColor & operator/=(f32 scalar)
スカラ除算代入
Definition GxColor.inl:133

GxColor::operator*=
GX_FORCE_INLINE GxColor & operator*=(f32 scalar)
スカラ乗算代入
Definition GxColor.inl:122

GxColor::addColor
GX_FORCE_INLINE const GxColor & addColor(const GxColor color)
カラー加算
Definition GxColor.inl:600

GxColor::getAddScalar
static GX_FORCE_INLINE const GxColor & getAddScalar(GxColor &dst, const GxColor color, u32 scalar)
スカラ加算を取得
Definition GxColor.inl:297

GxColor::getSubScalar
static GX_FORCE_INLINE const GxColor & getSubScalar(GxColor &dst, const GxColor color, u32 scalar)
スカラ減算を取得
Definition GxColor.inl:326

GxColor::_green
u32 _green
緑
Definition GxColor.h:226

GxColor::addScalar
GX_FORCE_INLINE const GxColor & addScalar(u32 scalar)
スカラ加算
Definition GxColor.inl:516

GxColor::getSubColor
static GX_FORCE_INLINE const GxColor & getSubColor(GxColor &dst, const GxColor color0, const GxColor color1)
カラー減算を取得
Definition GxColor.inl:421

GxColor::getMulColor
static GX_FORCE_INLINE const GxColor & getMulColor(GxColor &dst, const GxColor color0, const GxColor color1)
カラー乗算を取得
Definition GxColor.inl:451

GxColor::_red
u32 _red
赤
Definition GxColor.h:225

GxColor::operator=
GX_FORCE_INLINE GxColor & operator=(const GxColor color)
代入
Definition GxColor.inl:89

GxColor::_blue
u32 _blue
青
Definition GxColor.h:227

GxColor::divScalar
GX_FORCE_INLINE const GxColor & divScalar(f32 scalar)
スカラ除算
Definition GxColor.inl:584

GxColor::_alpha
u32 _alpha
アルファ
Definition GxColor.h:228

GxColor::subScalar
GX_FORCE_INLINE const GxColor & subScalar(u32 scalar)
スカラ減算
Definition GxColor.inl:543

GxColor::mulScalar
GX_FORCE_INLINE const GxColor & mulScalar(f32 scalar)
スカラ乗算
Definition GxColor.inl:570

GxColor::operator+=
GX_FORCE_INLINE GxColor & operator+=(u32 scalar)
スカラ加算代入
Definition GxColor.inl:100

GxColor::convertPs3ToWindows
static GX_FORCE_INLINE GxColor convertPs3ToWindows(const GxColor ps3Color)
PS3メモリ配置の色をWindowsメモリ配置の色に変換
Definition GxColor.inl:672

GxColor::getMulScalar
static GX_FORCE_INLINE const GxColor & getMulScalar(GxColor &dst, const GxColor color, f32 scalar)
スカラ乗算を取得
Definition GxColor.inl:355

GxColor::GxColor
GxColor(void)
デフォルトコンストラクタ
Definition GxColor.h:76

GxColor::getLerp
static GX_FORCE_INLINE GxColor getLerp(const GxColor color0, const GxColor color1, f32 t)
補間値を取得(互換用)
Definition GxColor.inl:468

GxColor::getAddColor
static GX_FORCE_INLINE const GxColor & getAddColor(GxColor &dst, const GxColor color0, const GxColor color1)
カラー加算を取得
Definition GxColor.inl:391

GxColor::operator-=
GX_FORCE_INLINE GxColor & operator-=(u32 scalar)
スカラ減算代入
Definition GxColor.inl:111

GxColor::mulColor
GX_FORCE_INLINE const GxColor & mulColor(const GxColor color)
カラー乗算
Definition GxColor.inl:656

GxColor::subColor
GX_FORCE_INLINE const GxColor & subColor(const GxColor color)
カラー減算
Definition GxColor.inl:628

b32
32bitブーリアン
Definition GxDefine.h:173