RGBREF _HSLtoRGB(RGBREF lHSLColor)
{
//<F. Livraghi> fixed implementation for HSL2RGB routine
float h,s,l;
float m1,m2;
BYTE r,g,b;
RGBREF ref;
h = (float)lHSLColor.rgb.Red * 360.0f/255.0f;
s = (float)lHSLColor.rgb.Green/255.0f;
l = (float)lHSLColor.rgb.Blue/255.0f;
if (l <= 0.5) m2 = l * (1+s);
else m2 = l + s - l*s;
m1 = 2 * l - m2;
if (s == 0) {
r=g=b=(BYTE)(l*255.0f);
} else {
r = (BYTE)(HueToRGB(m1,m2,h+120) * 255.0f);
g = (BYTE)(HueToRGB(m1,m2,h) * 255.0f);
b = (BYTE)(HueToRGB(m1,m2,h-120) * 255.0f);
}
ref.rgb.Red = r;
ref.rgb.Green = g;
ref.rgb.Blue = b;
ref.rgb.Alpha = 0;
return ref;
}
COLORREF dibFilterEFFECT::HSLtoRGB(float H,float S,float L)
{
BYTE r,g,b;
L = min(1,L);
S = min(1,S);
if(S == 0.0)
{
r = g = b = (BYTE)(255 * L);
}
else
{
float rm1, rm2;
if (L <= 0.5f)
rm2 = L + L * S;
else
rm2 = L + S - L * S;
rm1 = 2.0f * L - rm2;
r = HueToRGB(rm1, rm2, H + 120.0f);
g = HueToRGB(rm1, rm2, H);
b = HueToRGB(rm1, rm2, H - 120.0f);
}
return RGB(r,g,b);
}
RGBQUAD CxDib::HSLtoRGB(RGBQUAD lHSLColor)
{
WORD hue,lum,sat;
BYTE R,G,B; /* RGB component values */
WORD Magic1,Magic2; /* calculated magic numbers (really!) */
hue = lHSLColor.rgbRed; /* get H, S, and L out of DWORD */
sat = lHSLColor.rgbGreen;
lum = lHSLColor.rgbBlue;
if (sat == 0) { /* achromatic case */
R=G=B=(lum*RGBMAX)/HSLMAX;
} else { /* chromatic case */
/* set up magic numbers */
if (lum <= (HSLMAX/2))
Magic2 = (lum*(HSLMAX + sat) + (HSLMAX/2))/HSLMAX;
else
Magic2 = lum + sat - ((lum*sat) + (HSLMAX/2))/HSLMAX;
Magic1 = 2*lum-Magic2;
/* get RGB, change units from HSLMAX to RGBMAX */
R = (HueToRGB(Magic1,Magic2,(WORD)(hue+(HSLMAX/3)))*RGBMAX+(HSLMAX/2))/HSLMAX;
G = (HueToRGB(Magic1,Magic2,hue)*RGBMAX + (HSLMAX/2)) / HSLMAX;
B = (HueToRGB(Magic1,Magic2,(WORD)(hue-(HSLMAX/3)))*RGBMAX+(HSLMAX/2))/HSLMAX;
}
RGBQUAD rgb={B,G,R,0};
return rgb;
}
COLORREF HLStoRGB(const double H, const double L, const double S )
{
double r,g,b;
double m1, m2;
if(S == 0)
{
r = g = b = L;
}
else
{
if (L <= 0.5)
m2 = L * (1.0 + S);
else
m2 = L + S - L * S;
m1 = 2.0 * L - m2;
r = HueToRGB(m1,m2,H+1.0/3.0);
g = HueToRGB(m1,m2,H);
b = HueToRGB(m1,m2,H-1.0/3.0);
}
return RGB(r*255, g*255, b*255);
}
NWT_RGB HLStoRGB( HLS hls )
{
NWT_RGB rgb;
short Magic1, Magic2; /* calculated magic numbers (really!) */
if( hls.s == 0 )
{ /* achromatic case */
rgb.r = rgb.g = rgb.b = (unsigned char) ((hls.l * RGBMAX) / HLSMAX);
if( hls.h != UNDEFINED )
{
/* ERROR */
}
}
else
{ /* chromatic case */
/* set up magic numbers */
if( hls.l <= (HLSMAX / 2) )
Magic2 = (hls.l * (HLSMAX + hls.s) + (HLSMAX / 2)) / HLSMAX;
else
Magic2 = hls.l + hls.s - ((hls.l * hls.s) + (HLSMAX / 2)) / HLSMAX;
Magic1 = 2 * hls.l - Magic2;
/* get RGB, change units from HLSMAX to RGBMAX */
rgb.r = (unsigned char) ((HueToRGB (Magic1, Magic2, hls.h + (HLSMAX / 3)) * RGBMAX + (HLSMAX / 2)) / HLSMAX);
rgb.g = (unsigned char) ((HueToRGB (Magic1, Magic2, hls.h) * RGBMAX + (HLSMAX / 2)) / HLSMAX);
rgb.b = (unsigned char) ((HueToRGB (Magic1, Magic2, hls.h - (HLSMAX / 3)) * RGBMAX + (HLSMAX / 2)) / HLSMAX);
}
return rgb;
}
void wxColourExt::SetHSL(float h, float s, float l)
{
H0 = h;
S0 = s;
L0 = l;
last_mode_used = HSL;
unsigned char r = l * 255;
unsigned char g = l * 255;
unsigned char b = l * 255;
if(s != 0) {
float var_2 = 0;
if (l < 0.5) var_2 = l*(1 + s);
else var_2 = (l + s) - (s*l);
float var_1 = 2 * l - var_2;
r = 255 * HueToRGB(var_1, var_2, h + (1.0/3));
g = 255 * HueToRGB(var_1, var_2, h);
b = 255 * HueToRGB(var_1, var_2, h - (1.0/3));
}
Set(r, g, b);
}
void CThermalMaterialProxy::OnBind( C_BaseEntity *pEntity )
{
// FIXME, enable this later
return;
if( !m_ThermalVar )
{
return;
}
float min, max, period, value;
// set default values if these variables don't exist.
min = m_ThermalMin ? m_ThermalMin->GetFloatValue() : 0.0f;
max = m_ThermalMax ? m_ThermalMax->GetFloatValue() : 1.0f;
period = m_ThermalPeriod ? m_ThermalPeriod->GetFloatValue() : 1.0f;
// get a value in [0,1]
value = ( sin( 2.0f * M_PI * gpGlobals->curtime / period ) * 0.5f ) + 0.5f;
// get a value in [min,max]
value = ( max - min ) * value + min;
Vector color;
HueToRGB( 360.f * value, color );
m_ThermalVar->SetVecValue( color[0], color[1], color[2] );
}
void LightAnimation::CreateLightsWithAnimStatic()
{
const float3 SponzaExtentInner[] = {
float3(750, 10, -120),
float3(750, 10, 230),
float3(-950, 10, 230),
float3(-950, 10, -100) };
SceneManager* sceneMan = Environment::GetSingleton().GetSceneManager();
const int NumLightX = 40;
const int NumLightZ = 12;
for (int i = 0; i < NumLightZ; ++i)
{
float t = float(i) / NumLightZ;
float3 start = Lerp(SponzaExtentInner[0], SponzaExtentInner[1], t);
float3 end = Lerp(SponzaExtentInner[3], SponzaExtentInner[2], t);
for (int j = 0; j < NumLightX; ++j)
{
Light* light = sceneMan->CreateLight("", LT_PointLight);
light->SetPosition(Lerp(start, end, float(j)/NumLightX));
float3 color = IntensityDist(rng) * HueToRGB(HueDist(rng));
light->SetLightColor(color);
light->SetLightIntensity(1.0);
light->SetAttenuation(1.0f, 0.0f);
light->SetRange(25.0f);
sceneMan->GetRootSceneNode()->AttachObject(light);
mNumTotalLights++;
}
}
}
// Convert HLS to RGB.
/* static */ COLORREF MyGraph::HLStoRGB(WORD wH, WORD wL, WORD wS)
{
_ASSERTE(0 <= wH && 240 >= wH && "Illegal hue value");
_ASSERTE(0 <= wL && 240 >= wL && "Illegal lum value");
_ASSERTE(0 <= wS && 240 >= wS && "Illegal sat value");
WORD wR(0);
WORD wG(0);
WORD wB(0);
// Achromatic case.
if (0 == wS) {
wR = wG = wB = (wL * RGBMAX) / HLSMAX;
if (UNDEFINED != wH) {
_ASSERTE(! "ERROR");
}
}
else {
// Chromatic case.
WORD Magic1(0);
WORD Magic2(0);
// Set up magic numbers.
if (wL <= HLSMAX / 2) {
Magic2 = (wL * (HLSMAX + wS) + (HLSMAX / 2)) / HLSMAX;
}
else {
Magic2 = wL + wS - ((wL * wS) + (HLSMAX / 2)) / HLSMAX;
}
Magic1 = 2 * wL - Magic2;
// Get RGB, change units from HLSMAX to RGBMAX.
wR = (HueToRGB(Magic1, Magic2, wH + (HLSMAX / 3)) * RGBMAX + (HLSMAX / 2)) / HLSMAX;
wG = (HueToRGB(Magic1, Magic2, wH) * RGBMAX + (HLSMAX / 2)) / HLSMAX;
wB = (HueToRGB(Magic1, Magic2, wH - (HLSMAX / 3)) * RGBMAX + (HLSMAX / 2)) / HLSMAX;
}
return RGB(wR,wG,wB);
}
COLORREF HLSToRGB (int hue, int lum, int sat)
//converts a color given as (h,l,s) to RGB(r,g,b)
{
int r,g,b;
int Magic1, Magic2;
if (sat == 0) {
r = (lum * RGBMAX) / HLSMAX;
g = r;
b = r;
} else {
if (lum <= HLSMAX / 2)
Magic2 = (lum*(HLSMAX + sat) + (HLSMAX / 2)) / HLSMAX;
else
Magic2 = lum + sat - ((lum*sat) + (HLSMAX / 2)) / HLSMAX;
Magic1 = 2*lum-Magic2;
r = (HueToRGB (Magic1,Magic2,hue+(HLSMAX / 3))*RGBMAX + (HLSMAX / 2)) / HLSMAX;
g = (HueToRGB (Magic1,Magic2,hue)*RGBMAX + (HLSMAX / 2)) / HLSMAX;
b = (HueToRGB (Magic1,Magic2,hue-(HLSMAX / 3))*RGBMAX + (HLSMAX / 2)) / HLSMAX;
}
return RGB((unsigned char)r, (unsigned char)g, (unsigned char)b);
}
void LightAnimation::CreateLightsWithAnimLine()
{
SceneManager* sceneMan = Environment::GetSingleton().GetSceneManager();
const int NumBandLights[] = { 10, 20 };
for (int iFloor = 0; iFloor < 2; ++iFloor)
{
for (int iLine = 0; iLine < 4; ++iLine)
{
const int NumLight = NumBandLights[iLine & 0x1];
const float3 LeftPos = SponzaExtent[iLine];
const float3 RightPos = SponzaExtent[(iLine+1)%4];
for (int32_t iLight = 0; iLight < NumLight; ++iLight)
{
float3 position = Lerp(LeftPos, RightPos, float(iLight) / NumLight);
position.Y() = SponzaFloorHeightRange[iFloor][0];
//position.Y() = Lerp(SponzaFloorHeightRange[iFloor][0], SponzaFloorHeightRange[iFloor][1], NormDist(rng));
float3 color = IntensityDist(rng) * HueToRGB(HueDist(rng));
Light* light = sceneMan->CreateLight("", LT_PointLight);
light->SetPosition(position);
light->SetLightColor(color);
light->SetLightIntensity(1.0);
light->SetAttenuation(1.0f, 0.0f);
light->SetRange(100);
sceneMan->GetRootSceneNode()->AttachObject(light);
LineAnimatedLight aminLight;
aminLight.Light = light;
aminLight.LineIndex = iLine;
aminLight.FloorIndex = iFloor;
mLineAnimatedLights.push_back(aminLight);
mNumTotalLights++;
}
}
}
}
void LightAnimation::CreateLightsWithAnimEllipse()
{
SceneManager* sceneMan = Environment::GetSingleton().GetSceneManager();
const int NumEllipses = 10;
const int NumLightsEllipse = 40;
for (int i = 0; i < NumEllipses; ++i)
{
for (int j = 0; j < NumLightsEllipse; ++j)
{
EllipseAnimatedLight aminLight;
aminLight.EllipseWidth = 950.0f;
aminLight.EllipseHeight = 175.0f;
aminLight.Height = Lerp(100.0f, 1000.0f, float(i) / NumEllipses);
//aminLight.Angle = Mathf::TWO_PI / NumLightsEllipse * j;
aminLight.Angle = AngleDist(rng);
aminLight.AnimationSpeed = (AnimationDirection(rng) * 2 - 1) * AnimationSpeedDist(rng);
float3 pos(aminLight.EllipseWidth * cosf(aminLight.Angle), aminLight.Height, aminLight.EllipseHeight * sinf(aminLight.Angle));
float3 color = IntensityDist(rng) * HueToRGB(HueDist(rng));
Light* light = sceneMan->CreateLight("", LT_PointLight);
light->SetPosition(pos);
light->SetLightColor(color);
light->SetLightIntensity(1.0);
light->SetAttenuation(1.0f, 0.0f);
light->SetRange(100);
sceneMan->GetRootSceneNode()->AttachObject(light);
aminLight.Light = light;
mEllipseAnimatedLights.push_back(aminLight);
mNumTotalLights++;
}
}
}
///////////////////////////////////////////////////////////////////////
// Class : CShadingContext
// Method : convertColorFrom
// Description : Do color conversion
// Return Value : -
// Comments :
void convertColorFrom(float *out,const float *in,ECoordinateSystem s) {
switch(s) {
case COLOR_RGB:
movvv(out,in);
break;
case COLOR_HSL:
{
#define HueToRGB(r,m1,m2,h ) \
if (h<0) h+=1; \
if (h>1) h-=1; \
if (6.0*h < 1 ) r = (m1+(m2-m1)*h*6); \
else if (2.0*h < 1 ) r = m2; \
else if (3.0*h < 2.0) r = (m1+(m2-m1)*((2.0f/3.0f)-h)*6); \
else r = m1;
float m1,m2,h;
if (in[1]==0) initv(out,in[2],in[2],in[2]);
else {
if (in[2] <=0.5) m2 = in[2]*(1+in[1]);
else m2 = in[2]+in[1]-in[2]*in[1];
m1 = 2*in[2]-m2;
h = in[0] + (1.0f/3.0f); HueToRGB(out[0],m1,m2,h);
h = in[0]; HueToRGB(out[1],m1,m2,h);
h = in[0] - (1.0f/3.0f); HueToRGB(out[2],m1,m2,h);
}
#undef HueToRGB
}
break;
case COLOR_HSV:
{
if (in[1] < -1 || in[1] > 1) {
if (in[0] == 0) {
out[0] = in[2];
out[1] = in[2];
out[2] = in[2];
} else {
out[0] = in[0];
out[1] = in[1];
out[2] = in[2];
}
} else {
float f,p,q,t,h;
int i;
h = (float) fmod(in[0],1);
if (h < 0) h += 1;
h *= 6;
i = (int) floor(h);
f = h - i;
p = in[2]*(1-in[1]);
q = in[2]*(1-(in[1]*f));
t = in[2]*(1-(in[1]*(1-f)));
switch(i) {
case 0: out[COMP_R] = in[2]; out[COMP_G] = t; out[COMP_B] = p; break;
case 1: out[COMP_R] = q; out[COMP_G] = in[2]; out[COMP_B] = p; break;
case 2: out[COMP_R] = p; out[COMP_G] = in[2]; out[COMP_B] = t; break;
case 3: out[COMP_R] = p; out[COMP_G] = q; out[COMP_B] = in[2]; break;
case 4: out[COMP_R] = t; out[COMP_G] = p; out[COMP_B] = in[2]; break;
case 5: out[COMP_R] = in[2]; out[COMP_G] = p; out[COMP_B] = q; break;
}
}
}
break;
case COLOR_XYZ:
out[COMP_R] = (float) (3.24079*in[0] - 1.537150*in[1] - 0.498535*in[2]);
out[COMP_G] = (float) (-0.969256*in[0] + 1.875992*in[1] + 0.041556*in[2]);
out[COMP_B] = (float) (0.055648*in[0] - 0.204043*in[1] + 1.057311*in[2]);
break;
case COLOR_CIE:
out[COMP_R] = (float) (3.24079*in[0] - 1.537150*in[1] - 0.498535*in[2]);
out[COMP_G] = (float) (-0.969256*in[0] + 1.875992*in[1] + 0.041556*in[2]);
out[COMP_B] = (float) (0.055648*in[0] - 0.204043*in[1] + 1.057311*in[2]);
break;
case COLOR_YIQ:
out[COMP_R] = (float) (in[0] + 0.956*in[1] + 0.620*in[2]);
out[COMP_G] = (float) (in[0] - 0.272*in[1] - 0.647*in[2]);
out[COMP_B] = (float) (in[0] - 1.108*in[1] + 1.705*in[2]);
break;
case COLOR_XYY:
vector tin;
if (in[2] == 0) {
tin[0] = 0;
tin[1] = 0;
tin[2] = 0;
} else {
tin[0] = max(in[0]*in[2]/in[1],0);
tin[1] = in[2];
tin[2] = max((1-in[0]-in[1])*in[2]/in[1],0);
}
out[COMP_R] = (float) (3.24079*tin[0] - 1.537150*tin[1] - 0.498535*tin[2]);
out[COMP_G] = (float) (-0.969256*tin[0] + 1.875992*tin[1] + 0.041556*tin[2]);
out[COMP_B] = (float) (0.055648*tin[0] - 0.204043*tin[1] + 1.057311*tin[2]);
break;
default:
break;
}
}
