Fvector3 calc_temp( float temp ) // color temperature counter
{
    float r, g, b;

    temp /= 100.f;

    if( temp < 65.f ){
        r = 255.f;

        float green = temp - 2.f;
        g = (-155.25485562709179f - 0.44596950469579133f * green + 104.49216199393888f * log(green));

        if( temp > 20 )
        {
            float blue = temp - 10.f;
            b = (-254.76935184120902f + 0.8274096064007395f * blue + 115.67994401066147f * log(blue));
        }
    }
    else
    {
        b = 255.f;
        float red = temp - 55.f;
        r = (351.97690566805693f + 0.114206453784165f * red - 40.25366309332127f * log(red));
        float green = temp - 50.f;
        g = (325.4494125711974f + 0.07943456536662342f * green - 28.0852963507957f * log(green));
    }

    clamp( r, 0.f, 255.f ); // это можно перевести в фвектор и клампить одним махом
    clamp( g, 0.f, 255.f );
    clamp( b, 0.f, 255.f );

    Fvector3 out;

    out.x = r/255.f; // это можно делить одним махом как фвектор
    out.y = g/255.f;
    out.z = b/255.f;

    return out;
}

// цветовые температуры

float sun_maxtemp_nofog = 6000; // солнышко в зените без тумана
float sun_mintemp_nofog = 1400; // солнышко у горизонта без тумана
float sun_maxtemp_fog = 6500; // солнышко в зените в полный туман
float sun_mintemp_fog = 6000; // солнышко у горизонта в полный туман

float moon_maxtemp_nofog = 5500; // луна в зените без тумана
float moon_mintemp_nofog = 3000; // луна на горизонте без тумана
float moon_maxtemp_fog = 5500; // луна в зените в полный туман (а ее хоть будет видно, але?)
float moon_mintemp_fog = 5500; // луна у горизонта в полный туман

float hour_sunrise = 5.f; // когда всходит солнышко
float hour_sunset = 22.f; // когда заходит

float moon_multiplier = .3f; // насколько луна меньше светит чем солнце. Сейчас втрое меньше

void CEnvironment::calculate_dynamic_sun_dir()
{
    //if( CurrentCycleName != "auto" ) return;

    bool isMoon = fGameTime < 60.f*60.f*hour_sunrise || fGameTime > 60.f*60.f*hour_sunset;

    float fGameTime2 = isMoon ? fGameTime - (86400.f-60.f*60.f*12) : fGameTime;

        float g = (360.0f/365.25f)*(180.0f + fGameTime2/DAY_LENGTH);

        g = deg2rad(g);

        //    Declination
        float D = 0.396372f-22.91327f*_cos(g)+4.02543f*_sin(g)-0.387205f*_cos(2*g)+
            0.051967f*_sin(2*g)-0.154527f*_cos(3*g) + 0.084798f*_sin(3*g);

        //    Now calculate the time correction for solar angle:
        float TC = 0.004297f+0.107029f*_cos(g)-1.837877f*_sin(g)-0.837378f*_cos(2*g)-
            2.340475f*_sin(2*g);

        //    IN degrees
        float Longitude = -30.4f;

        float SHA = (fGameTime2/(DAY_LENGTH/24.f)-12.f)*15.f + Longitude + TC + 180.f;

        //    Need this to correctly determine SHA sign
        if (SHA>180) SHA -= 360;
        if (SHA<-180) SHA += 360;

        //    IN degrees
        float const Latitude = 50.27f;
        float const LatitudeR = deg2rad(Latitude);

        //    Now we can calculate the Sun Zenith Angle (SZA):
        float cosSZA = _sin(LatitudeR)
            * _sin(deg2rad(D)) + _cos(LatitudeR)*
            _cos(deg2rad(D)) * _cos(deg2rad(SHA));

        clamp( cosSZA, -1.0f, 1.0f);

        float SZA = acosf(cosSZA);
        float elevation = PI_DIV_2-SZA+PI_DIV_8;
        clamp( elevation, 0.f, 1.f );
        elevation = 1.f - elevation;
        //    To finish we will calculate the Azimuth Angle (AZ):
        float cosAZ = 0.f;
        float const sin_SZA = _sin(SZA);
        float const cos_Latitude = _cos(LatitudeR);
        float const sin_SZA_X_cos_Latitude = sin_SZA*cos_Latitude;
        if (!fis_zero(sin_SZA_X_cos_Latitude))
            cosAZ    = (_sin(deg2rad(D))-_sin(LatitudeR)*_cos(SZA))/sin_SZA_X_cos_Latitude;

        clamp( cosAZ, -1.0f, 1.0f);
        float azimuth = acosf(cosAZ);

        if (SHA<0)
            azimuth = 2*PI-azimuth;
    
    float mintemp_nofog = 0.f;
    float maxtemp_nofog = 0.f;
    float mintemp_fog = 0.f;
    float maxtemp_fog = 0.f;

    if( isMoon )
    {
        mintemp_nofog = moon_mintemp_nofog;
        maxtemp_nofog = moon_maxtemp_nofog;
        mintemp_fog      = moon_mintemp_fog;
        maxtemp_fog   = moon_maxtemp_fog;
    }
    else
    {
        mintemp_nofog = sun_mintemp_nofog;
        maxtemp_nofog = sun_maxtemp_nofog;
        mintemp_fog      = sun_mintemp_fog;
        maxtemp_fog   = sun_maxtemp_fog;
    }

    float sunbright = 1.f;

    if(    fGameTime >= hour_sunset*60.f*60.f) // когда всходит луна
    {
        float result = ((hour_sunset+1.f)*60.f*60.f) - fGameTime;
        result /= (60.f * 60.f);
        clamp( result, 1.f-moon_multiplier, 1.f );
        sunbright = 1.f - result;
    }

    if(    fGameTime <= (hour_sunrise-1.f)*60.f*60.f) // утром (нужно переделывать бо бажній участок кода)
    {
        float result = fGameTime - ((hour_sunset-1.f)*60.f*60.f);
        result /= (60.f * 60.f);
        clamp( result, moon_multiplier, 1.0f );
        sunbright = result;
    }

    if( elevation < 0.33f )
    {
        sunbright *= 3.f * elevation;
    }

    float fogginess = CurrentEnv.rain_density + .1f; // ugly hack to determine fog

    float temp_nofog = mintemp_nofog*(1.f-elevation)+maxtemp_nofog*elevation;
    float temp_fog = mintemp_fog*(1.f-elevation)+maxtemp_fog*elevation;
    float temp = temp_nofog*(1.f-fogginess)+temp_fog*fogginess;

    CurrentEnv.sun_dir.setHP    (azimuth,-elevation);
    CurrentEnv.sky_rotation += -azimuth - PI_DIV_4 - .2f; // little bigger than pi_div_4
    CurrentEnv.sun_color.set(calc_temp(temp));
    CurrentEnv.sun_color.mul(sunbright);

    CurrentEnv.hemi_color.mul(sunbright);
    CurrentEnv.ambient.mul(sunbright);
    CurrentEnv.sky_color.mul(sunbright);
    CurrentEnv.fog_color.mul(sunbright);

    CurrentEnv.sun_color.mul(1.f - fogginess);
}

void    game_cl_GameState::net_import_GameTime        (NET_Packet& P)
{
    //time
    u64                GameTime;
    P.r_u64            (GameTime);
    float            TimeFactor;
    P.r_float        (TimeFactor);

    
    Level().SetGameTimeFactor    (GameTime,TimeFactor);

    u64                GameEnvironmentTime;
    P.r_u64            (GameEnvironmentTime);
    float            EnvironmentTimeFactor;
    P.r_float        (EnvironmentTimeFactor);

    u64 OldTime = Level().GetEnvironmentGameTime();
    Level().SetEnvironmentGameTimeFactor    (GameEnvironmentTime,EnvironmentTimeFactor);
    //if (OldTime > GameEnvironmentTime) // комментарим вот это
    //    GamePersistent().Environment().Invalidate(); // и это
}