Serious-Engine/Sources/Engine/Graphics/Color.h
Ryan C. Gordon 24cb244d43 First attempt to hand-merge Ryan's Linux and Mac OS X port.
This was a _ton_ of changes, made 15 years ago, so there are probably some
problems to work out still.

Among others: Engine/Base/Stream.* was mostly abandoned and will need to be
re-ported.

Still, this is a pretty good start, and probably holds a world record for
lines of changes or something.  :)
2016-03-28 23:46:13 -04:00

368 lines
10 KiB
C

/* Copyright (c) 2002-2012 Croteam Ltd. All rights reserved. */
#ifndef SE_INCL_COLOR_H
#define SE_INCL_COLOR_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include <Engine/Math/Functions.h>
// color definition constants (in CroTeam RGBA format)
#define C_BLACK 0x00000000UL
#define C_vdGRAY 0x1F1F1F00UL
#define C_dGRAY 0x3F3F3F00UL
#define C_mdGRAY 0x5F5F5F00UL
#define C_GRAY 0x7F7F7F00UL
#define C_mlGRAY 0x9F9F9F00UL
#define C_lGRAY 0xBFBFBF00UL
#define C_vlGRAY 0xDFDFDF00UL
#define C_WHITE 0xFFFFFF00UL
#define C_vdRED 0x3F000000UL
#define C_dRED 0x7F000000UL
#define C_mdRED 0xBF000000UL
#define C_RED 0xFF000000UL
#define C_mlRED 0xFF3F3F00UL
#define C_lRED 0xFF7F7F00UL
#define C_vlRED 0xFFBFBF00UL
#define C_vdGREEN 0x003F0000UL
#define C_dGREEN 0x007F0000UL
#define C_mdGREEN 0x00BF0000UL
#define C_GREEN 0x00FF0000UL
#define C_mlGREEN 0x3FFF3F00UL
#define C_lGREEN 0x7FFF7F00UL
#define C_vlGREEN 0xBFFFBF00UL
#define C_vdBLUE 0x00003F00UL
#define C_dBLUE 0x00007F00UL
#define C_mdBLUE 0x0000BF00UL
#define C_BLUE 0x0000FF00UL
#define C_mlBLUE 0x3F3FFF00UL
#define C_lBLUE 0x7F7FFF00UL
#define C_vlBLUE 0xBFBFFF00UL
#define C_vdCYAN 0x003F3F00UL
#define C_dCYAN 0x007F7F00UL
#define C_mdCYAN 0x00BFBF00UL
#define C_CYAN 0x00FFFF00UL
#define C_mlCYAN 0x3FFFFF00UL
#define C_lCYAN 0x7FFFFF00UL
#define C_vlCYAN 0xBFFFFF00UL
#define C_vdMAGENTA 0x3F003F00UL
#define C_dMAGENTA 0x7F007F00UL
#define C_mdMAGENTA 0xBF00BF00UL
#define C_MAGENTA 0xFF00FF00UL
#define C_mlMAGENTA 0xFF3FFF00UL
#define C_lMAGENTA 0xFF7FFF00UL
#define C_vlMAGENTA 0xFFBFFF00UL
#define C_vdYELLOW 0x3F3F0000UL
#define C_dYELLOW 0x7F7F0000UL
#define C_mdYELLOW 0xBFBF0000UL
#define C_YELLOW 0xFFFF0000UL
#define C_mlYELLOW 0xFFFF3F00UL
#define C_lYELLOW 0xFFFF7F00UL
#define C_vlYELLOW 0xFFFFBF00UL
#define C_vdORANGE 0x5F1F0000UL
#define C_dORANGE 0x7F3F0000UL
#define C_mdORANGE 0x9F5F0000UL
#define C_ORANGE 0xFF7F3F00UL
#define C_mlORANGE 0xFF9F5F00UL
#define C_lORANGE 0xFFBF7F00UL
#define C_vlORANGE 0xFFFF9F00UL
#define C_vdBROWN 0x3F1F0000UL
#define C_dBROWN 0x5F3F0F00UL
#define C_mdBROWN 0x7F5F1F00UL
#define C_BROWN 0x8C271700UL
#define C_mlBROWN 0xBF3F0F00UL
#define C_lBROWN 0xBF7F1F00UL
#define C_vlBROWN 0xBFBF3F00UL
#define C_vdPINK 0x9A545400UL
#define C_dPINK 0xAA646400UL
#define C_mdPINK 0xBA747400UL
#define C_PINK 0xC8787800UL
#define C_mlPINK 0xD67C7C00UL
#define C_lPINK 0xE68C8C00UL
#define C_vlPINK 0xF68C8C00UL
// CT RGBA masks and shifts
// Beware that changing these breaks the GNU C version of some
// inline assembly. --ryan.
#define CT_RMASK 0xFF000000UL
#define CT_GMASK 0x00FF0000UL
#define CT_BMASK 0x0000FF00UL
#define CT_AMASK 0x000000FFUL
#define CT_RSHIFT 24
#define CT_GSHIFT 16
#define CT_BSHIFT 8
#define CT_ASHIFT 0
// reversed (OpenGL) RGBA masks and shifts
#define CT_rRMASK 0x000000FFUL
#define CT_rGMASK 0x0000FF00UL
#define CT_rBMASK 0x00FF0000UL
#define CT_rAMASK 0xFF000000UL
#define CT_rRSHIFT 0
#define CT_rGSHIFT 8
#define CT_rBSHIFT 16
#define CT_rASHIFT 24
// global factors for saturation and stuff
extern SLONG _slTexSaturation;
extern SLONG _slTexHueShift;
extern SLONG _slShdSaturation;
extern SLONG _slShdHueShift;
// COLOR FORMAT CONVERSION ROUTINES
// convert separate R,G and B color components to CroTeam COLOR format (ULONG type)
__forceinline COLOR RGBToColor( UBYTE const ubR, UBYTE const ubG, UBYTE const ubB) {
return ((ULONG)ubR<<CT_RSHIFT) | ((ULONG)ubG<<CT_GSHIFT) | ((ULONG)ubB<<CT_BSHIFT);
}
// convert CroTeam COLOR format to separate R,G and B color components
__forceinline void ColorToRGB( COLOR const col, UBYTE &ubR, UBYTE &ubG, UBYTE &ubB) {
ubR = (col&CT_RMASK)>>CT_RSHIFT;
ubG = (col&CT_GMASK)>>CT_GSHIFT;
ubB = (col&CT_BMASK)>>CT_BSHIFT;
}
// combine CroTeam COLOR format from separate R,G and B color components
__forceinline COLOR RGBAToColor( UBYTE const ubR, UBYTE const ubG, UBYTE const ubB, UBYTE const ubA) {
return ((ULONG)ubR<<CT_RSHIFT) | ((ULONG)ubG<<CT_GSHIFT)
| ((ULONG)ubB<<CT_BSHIFT) | ((ULONG)ubA<<CT_ASHIFT);
}
// separate CroTeam COLOR format to R,G and B color components
__forceinline void ColorToRGBA( COLOR const col, UBYTE &ubR, UBYTE &ubG, UBYTE &ubB, UBYTE &ubA) {
ubR = (col&CT_RMASK)>>CT_RSHIFT;
ubG = (col&CT_GMASK)>>CT_GSHIFT;
ubB = (col&CT_BMASK)>>CT_BSHIFT;
ubA = (col&CT_AMASK)>>CT_ASHIFT;
}
// convert HSV components to CroTeam COLOR format
ENGINE_API extern COLOR HSVToColor( UBYTE const ubH, UBYTE const ubS, UBYTE const ubV);
// convert CroTeam COLOR format to HSV components
ENGINE_API extern void ColorToHSV( COLOR const colSrc, UBYTE &ubH, UBYTE &ubS, UBYTE &ubV);
// convert HSVA components to CroTeam COLOR format
__forceinline COLOR HSVAToColor( UBYTE const ubH, UBYTE const ubS, UBYTE const ubV, UBYTE const ubA) {
return HSVToColor( ubH,ubS,ubV) | ((ULONG)ubA<<CT_ASHIFT);
}
// convert CroTeam COLOR format to HSVA components
__forceinline void ColorToHSVA( COLOR const colSrc, UBYTE &ubH, UBYTE &ubS, UBYTE &ubV, UBYTE &ubA) {
ColorToHSV( colSrc, ubH,ubS,ubV);
ubA = (colSrc&CT_AMASK)>>CT_ASHIFT;
}
// is color gray, black or white?
ENGINE_API extern BOOL IsGray( COLOR const col);
ENGINE_API extern BOOL IsBlack( COLOR const col);
ENGINE_API extern BOOL IsWhite( COLOR const col);
// find corresponding desaturated color (it's not same as gray!)
ENGINE_API extern COLOR DesaturateColor( COLOR const col);
// is color1 bigger than color2 (gray comparison)
ENGINE_API extern BOOL IsBigger( COLOR const col1, COLOR const col2);
// has color same hue and saturation (with little tolerance) ?
ENGINE_API extern BOOL CompareChroma( COLOR col1, COLOR col2);
// adjust color saturation and/or hue (hue shift in 0-255 range!)
ENGINE_API extern COLOR AdjustColor( COLOR const col, SLONG const slHueShift, SLONG const slSaturation);
ENGINE_API extern COLOR AdjustGamma( COLOR const col, FLOAT const fGamma);
// color lerping functions
ENGINE_API extern COLOR LerpColor( COLOR col0, COLOR col1, FLOAT fRatio);
ENGINE_API extern void LerpColor( COLOR col0, COLOR col1, FLOAT fRatio, UBYTE &ubR, UBYTE &ubG, UBYTE &ubB);
// some fast color manipulation functions
ENGINE_API extern COLOR MulColors( COLOR col1, COLOR col2); // fast color multiply function - RES = 1ST * 2ND /255
ENGINE_API extern COLOR AddColors( COLOR col1, COLOR col2); // fast color additon function - RES = clamp (1ST + 2ND)
// converts colors between Croteam, OpenGL and DirectX
__forceinline ULONG ByteSwap( ULONG ul)
{
/* rcg10052001 Platform-wrappers. */
#if (defined USE_PORTABLE_C)
ul = ( ((ul << 24) ) |
((ul << 8) & 0x00FF0000) |
((ul >> 8) & 0x0000FF00) |
((ul >> 24) ) );
#if (defined PLATFORM_BIGENDIAN)
BYTESWAP(ul); // !!! FIXME: May not be right!
#endif
return(ul);
#elif (defined __MSVC_INLINE__)
ULONG ulRet;
__asm {
mov eax,dword ptr [ul]
bswap eax
mov dword ptr [ulRet],eax
}
return ulRet;
#elif (defined __GNU_INLINE__)
__asm__ __volatile__ (
"bswapl %%eax \n\t"
: "=a" (ul)
: "a" (ul)
);
return(ul);
#else
#error please define for your platform.
#endif
}
__forceinline ULONG rgba2argb( ULONG ul)
{
#if (defined USE_PORTABLE_C)
return( (ul << 24) | (ul >> 8) );
#elif (defined __MSVC_INLINE__)
ULONG ulRet;
__asm {
mov eax,dword ptr [ul]
ror eax,8
mov dword ptr [ulRet],eax
}
return ulRet;
#elif (defined __GNU_INLINE__)
ULONG ulRet;
__asm__ __volatile__ (
"rorl $8, %%eax \n\t"
: "=a" (ulRet)
: "a" (ul)
: "cc"
);
return ulRet;
#else
#error please define for your platform.
#endif
}
__forceinline ULONG abgr2argb( COLOR col)
{
#if (defined USE_PORTABLE_C)
// this could be simplified, this is just a safe conversion from asm code
col = ( ((col << 24) ) |
((col << 8) & 0x00FF0000) |
((col >> 8) & 0x0000FF00) |
((col >> 24) ) );
return( (col << 24) | (col >> 8) );
#elif (defined __MSVC_INLINE__)
ULONG ulRet;
__asm {
mov eax,dword ptr [col]
bswap eax
ror eax,8
mov dword ptr [ulRet],eax
}
return ulRet;
#elif (defined __GNU_INLINE__)
ULONG ulRet;
__asm__ __volatile__ (
"bswapl %%eax \n\t"
"rorl $8, %%eax \n\t"
: "=a" (ulRet)
: "a" (col)
: "cc"
);
return ulRet;
#else
#error please define for your platform.
#endif
}
// multiple conversion from OpenGL color to DirectX color
extern void abgr2argb( ULONG *pulSrc, ULONG *pulDst, INDEX ct);
// fast memory copy of ULONGs
inline void CopyLongs( ULONG *pulSrc, ULONG *pulDst, INDEX ctLongs)
{
#if ((defined USE_PORTABLE_C) || (PLATFORM_MACOSX))
memcpy( pulDst, pulSrc, ctLongs*4);
#elif (defined __MSVC_INLINE__)
__asm {
cld
mov esi,dword ptr [pulSrc]
mov edi,dword ptr [pulDst]
mov ecx,dword ptr [ctLongs]
rep movsd
}
#elif (defined __GNU_INLINE__)
// I haven't benchmarked it, but in many cases, memcpy() becomes an
// inline (asm?) macro on GNU platforms, so this might not be a
// speed gain at all over the USE_PORTABLE_C version.
// You Have Been Warned. --ryan.
__asm__ __volatile__ (
"cld \n\t"
"rep \n\t"
"movsd \n\t"
: // no outputs.
: "S" (pulSrc), "D" (pulDst), "c" (ctLongs)
: "cc", "memory"
);
#else
# error Please fill this in for your platform.
#endif
}
// fast memory set of ULONGs
inline void StoreLongs( ULONG ulVal, ULONG *pulDst, INDEX ctLongs)
{
#if (defined USE_PORTABLE_C)
for( INDEX i=0; i<ctLongs; i++)
pulDst[i] = ulVal;
#elif (defined __MSVC_INLINE__)
__asm {
cld
mov eax,dword ptr [ulVal]
mov edi,dword ptr [pulDst]
mov ecx,dword ptr [ctLongs]
rep stosd
}
#elif (defined __GNU_INLINE__)
__asm__ __volatile__ (
"cld \n\t"
"rep \n\t"
"stosd \n\t"
: // no outputs.
: "a" (ulVal), "D" (pulDst), "c" (ctLongs)
: "cc", "memory"
);
#else
# error Please fill this in for your platform.
#endif
}
#endif /* include-once check. */