weather.cpp

Go to the documentation of this file.

#include "weather.h"
#include "Viewscreen.h"
#include "../MathUtilities.h"

weather::weather(Viewscreen* ptr)
{
        viewscreen = ptr;
        logger = ptr->logger;
}

void weather::FrameMove(float fElapsedTime)
{
        logger->AddToCallStack("weather::FrameMove");

        D3DXVECTOR3 result;
        D3DXCOLOR colorzenith;
        const D3DXVECTOR3 Xsunlight = viewscreen->sunlight.Direction; // Start of the ray
        // ReSharper disable once CppJoinDeclarationAndAssignment
        HRESULT hr;

        // LIGHTNING FROM LEGACY CLIENT-----------------------------------------------------------------------------
        const float scaledTurbidity = GetTurbidity() - 2.0f; // now 0-14
        const float scaledTurbulence = scaledTurbidity * GetTurbulence() * 18.214f; // 0-255;

        if (!g_bAboveClouds && rand() < static_cast<short>(scaledTurbulence * 2.0f)) // made 2.0f*as likely now
        {
                // so no storm is 2 so 14+0 is 14 minus 0-14 randomly is 0-14
                // bad storm is 16 so 14+14 is 28 minus 0-14 randomly is 14-28
                float distance = 14.0f + scaledTurbidity - RandomFloat() * 14.0f;
                // no storm is 2 so distance would now be 0-0.5 ... 
                // bad storm is 16 so distance would now be 0.5 to 1 ...
                distance /= 28.0f; // based on a 10 this would give values from .41 to 1.0
                if (distance > 0.0f) // 1 is very close, 0 is far away
                {
                        const float intensity = RandomFloat(); // 1.0f is violent
                        const float seconds = (1.0f - distance) * 15.0f; // seconds
                        const float volume = sqrtf(distance * intensity) * viewscreen->ptrPropulsion->staticDensity; // volume

                        if (volume > 0.5f && rand() % 2 && intensity > 0.5f && viewscreen->gameclass->GUI->player[viewscreen->gameclass->GUI->ourplayerC].frame == 0)
                        {
                                viewscreen->gameclass->sound->Play(SOUND_SPEAKERPOP);
                                if (distance > 0.98f) // 2%
                                        viewscreen->ptrWeapon->EnergyWeaponImpact();
                        }

                        viewscreen->gameclass->sound->AddDelayedSound(SOUND_THUNDER1 + rand() % 15, seconds, volume * viewscreen->gameclass->sound->GetAttenuation(false));
                        viewscreen->TriggerBCLLightning(distance, intensity);

                        char msg[99];
                        sprintf_s(msg, sizeof(msg), "Lightning!  Distance: %.3f  Intensity: %.3f", seconds, volume * viewscreen->gameclass->sound->GetAttenuation(false));
                        logger->Log(msg);
                }
        }

        // this datapacket.f_z is from the client to the sound module and appears to have been calculated
        if (!hullionization && GetTurbidity() > 12.5f)
        {
                hullionization = true;
                if (playerships[0].reference != REF_ONGROUND)
                {
                        Command command;
                        command.name = "AuralHullIonization";
                        viewscreen->gameclass->bus->commandStream.emplace_back(command);
                        logger->Log("Hull ionization detected!");
                }
        }
        if (hullionization && GetTurbidity() < 12.5f)
                hullionization = false;


        // Fog calculation routines --------------------------------------------------------------


        // Above or below clouds and sunlight on or off and set g_bAboveClouds
        if (f_MSL > cloudTopsMslC)
        {
                if (!g_bAboveClouds)
                {
                        g_bAboveClouds = true;
                        if (playerships[0].reference == REF_APNMODE)
                                playerships[0].reference = REF_ACLMODE;

                        logger->Log("----------------------------------- ACMPL");

                        // Not sure why but this caused the program to crash
                /*              for (t=0; t<citytextureC; t++)
                                {
                                        m_pddsCityTexture[t]->SetPriority(0); // default priority
                                        m_pddsCityLights[t]->SetPriority(0);
                                }
                                // fireworks, lightning below clouds, cloud bases, terrain
                                for (t=0; t<docktextureC; t++)
                                {
                                        m_pddsDockTexture[t]->SetPriority(1); // higher priority
                                        m_pddsDockLights[t]->SetPriority(1);
                                }
                */              // also should do cloud upper layer, lightning above clouds
                // flare, cockpit should be on 3
                }
        }
        else if (f_MSL < cloudBufferMslC)
        {
                if (g_bAboveClouds)
                {
                        g_bAboveClouds = false;
                        if (playerships[0].reference == REF_ACLMODE)
                                playerships[0].reference = REF_APNMODE;

                        cloudCeilingSmoothAglKm = cloudCeilingTargetKm;
                        cloudSurfaceSmoothKm = cloudSurfaceTargetKm;

                        logger->Log("----------------------------------- BCMPL");

                        // Not sure why but this caused the program to crash
                /*      for (t=0; t<citytextureC; t++)
                        {
                                m_pddsCityTexture[t]->SetPriority(1); // higher priority
                                m_pddsCityLights[t]->SetPriority(1);
                        }
                        for (t=0; t<docktextureC; t++)
                        {
                                m_pddsDockTexture[t]->SetPriority(0); // default priority
                                m_pddsDockLights[t]->SetPriority(0);
                        }
                */
                // Request new grid, happens here, 000COMMANDC0, cubeface, and on VP load if on the ground
        //              cube=oldcube=game->CalculateCube( playerships[0].position );
        //                if (cube==-1)
        //                {
        //                                              char msg[99];
        //                                              sprintf_s(msg, sizeof(msg), "HG2 trapped a violation cube -1 for position x:%f y:%f z:%f", playerships[0].position.x, playerships[0].position.y, playerships[0].position.z);
        //                                              logger->Log(msg);
        //                                              MessageBox(DXUTGetHWND(), L"Encountered a telemetry error!\n\nPlease send the \"trace.log\" to \"support@risetvp.com\" before reloading.\n\nSorry for the inconvenience and thanks for helping us track down a bug!", L"Program fault!", MB_OK | MB_ICONERROR );
        //                }
        //              tcp=oldtcp=game->CalculateCGC( playerships[0].position, cube );
        //
        //       SClientPacket outpacket;
        //       outpacket.type=16; // Terrain request
        //       outpacket.f_x=tcp.u;
        //       outpacket.f_y=tcp.v;
        //       outpacket.f_z=cube;
        //               ground.gridready=false; // VB not set
        //               ground.initialized=false; // Wait on stuff until main grid is received, reset if above clouds
        //               ground.waiting=99;
        //      outpacket.f_w=0.0f; // Whole grid
        //      game->gameclass->networking->SendToServer( &outpacket, sizeof(SClientPacket), true, 0 );
        //      // Ambient light level is always calculated (dynamically) therefore not in this condition
                }
        }

        float f_temp;
        // Distance from CG
        if (f_MSL > 0.0f)
                f_temp = f_MSL + radiusC;
        else
                f_temp = radiusC;

        // Sun elevation (light level hitting flat plane)
        if (!playerships[0].simulator)
        {
                const float angle = D3DX_HALFPI - acosf(radiusC / f_temp); // one half view width on surface (1A)
                D3DXVECTOR3 result1 = -viewscreen->posnorml;
                elevation = D3DXVec3Dot(&result1, &Xsunlight); // Elevation needs adjustment after cloud illum.
                elevation += cosf(angle); // passed in, accounts for the planet obstructing our view
                if (elevation > 1.0f)
                        elevation = 1.0f;
        }
        else
        {
                elevation = 1.0f; // needs to be adjustable by slider
        }



        float inview;
        if (viewscreen->m_bDeviceSupportsVizQuery)
        {
                inview = static_cast<float>(m_dwSunViz) / powf(viewscreen->gameclass->displayWidth / 1024.0f * 10.25f, 2.0f);
                //      f_temp=sqrtf(f_temp);
                //      inview=f_temp*0.1f*inview-0.9f;
                if (inview < 0.0f)
                        inview = 0.0f;
                else if (inview > 0.9f)
                        inview = 0.9f;
        }
        else
        {
                inview = -D3DXVec3Dot(&viewscreen->headlightvec, &Xsunlight); // 1 means it is in view
                if (inview < 0.0f)
                        inview = 0.0f;
        }


        // Shear rate calculations ----------------------------------------------------------------------
        D3DXVec3Subtract(&result, &playerships[0].velocity, &playerships[0].barycentric);
        shearRate = D3DXVec3Length(&result) + 0.0353f * cosf(viewscreen->gameclass->bus->LatitudeRad);
        shearRate *= 0.6f * fElapsedTime; // /1.5km to be safe in which it can change over
        if (shearRate > 100.0f || shearRate < -100.0f || _isnan(shearRate) || isinf(shearRate))
        {
                sprintf_s(msg, sizeof(msg), "   velocity %.3f %.3f %.3f", playerships[0].velocity.x, playerships[0].velocity.y, playerships[0].velocity.z);
                logger->Log(msg, Logger::Level::Warn);
                sprintf_s(msg, sizeof(msg), "   barycentric %.3f %.3f %.3f", playerships[0].barycentric.x, playerships[0].barycentric.y, playerships[0].barycentric.z);
                logger->Log(msg, Logger::Level::Warn);
                sprintf_s(msg, sizeof(msg), "   LatitudeRad %.3f", viewscreen->gameclass->bus->LatitudeRad);
                logger->Log(msg, Logger::Level::Warn);
                sprintf_s(msg, sizeof(msg), "Trapped a violation with shearRate...");
                logger->Log(msg, Logger::Level::Error);
        }


        // Turbidity smoothing -----------------------------------------------------------------------
        if (g_bAboveClouds)
        {
                SetTurbidity(1.0f); // theoretical limit of pure clean air
                smoothTurbidity = 1.0f;
        }
        if (smoothTurbidity != -1.0f)
        {
                if (smoothTurbidity < turbidity)
                {
                        smoothTurbidity += shearRate;
                        if (smoothTurbidity > turbidity)
                                smoothTurbidity = turbidity;
                }
                else if (smoothTurbidity > turbidity)
                {
                        smoothTurbidity -= shearRate;
                        if (smoothTurbidity < turbidity)
                                smoothTurbidity = turbidity;
                }
        }
        viewscreen->gameclass->bus->DebugTurbidity = smoothTurbidity;



        if (cloudCeilingSmoothAglKm != -1.0f) // got a target value
        {
                f_temp = cloudCeilingTargetKm - cloudCeilingSmoothAglKm;
                cloudCeilingSmoothAglKm += f_temp * fElapsedTime * 0.01f; // 50 meters in 100 seconds
        }
        viewscreen->gameclass->bus->DebugCeiling = cloudCeilingSmoothAglKm;
        

        if (cloudSurfaceSmoothKm != -1.0f) // got a target value
        {
                f_temp = cloudSurfaceTargetKm - cloudSurfaceSmoothKm;
                cloudSurfaceSmoothKm += f_temp * fElapsedTime * 0.01f;
        }

        if (cloudSurfaceSmoothKm != -1.0f && cloudCeilingSmoothAglKm != -1.0f && !g_bAboveClouds && f_MSL != -1.0f)
                f_BCL = GetCloudCeilingMslKm() - f_MSL;
        else
                f_BCL = -20.0f;

        cloudThickness = cloudTopsMslC - GetCloudCeilingMslKm();


        // Inside cloud adjustment of turbidity
        if (g_bAboveClouds)
                f_temp = f_ACL;
        else
                f_temp = f_BCL;


        if (f_temp <= 0.0f && f_temp > -20.0f) // in cloud
        {
                viewscreen->alphascreen.a = cloudVisTarget = cloudVisSmooth = 0.0f; // no visibility
        }
        else if (f_temp > 0.0f && f_temp <= 0.05f) // Failsafe transition zone 50m
        {
                // take existing smooth value and modulate it (and the target) forceable to 0
                viewscreen->alphascreen.a = cloudVisTarget = cloudVisSmooth * f_temp / 0.05f;
        }
        else // above or below the transition area
        {
                if (f_temp > 0.15f || f_temp == -20.0f) // in the clear 150 meters above or below the cloud layer
                        cloudVisTarget = cloudVisSmooth = 1.0f;
                else if (cloudVisSmooth == cloudVisTarget) // Between 0.05 and 0.15 pick a new target based on +/- f_temp/0.15f
                        cloudVisTarget = (f_temp - 0.05f) / 0.1f - (RandomFloat() * (f_temp - 0.05f) / 0.1f * 0.25f);

                // Speed at which we arrive at new target is based on our tangent
                if (cloudVisSmooth < cloudVisTarget)
                {
                        cloudVisSmooth += D3DXVec3Length(&locvelcomp) * fElapsedTime * 5.0f;
                        if (cloudVisSmooth > cloudVisTarget)
                                cloudVisSmooth = cloudVisTarget;
                }
                else if (cloudVisSmooth > cloudVisTarget)
                {
                        cloudVisSmooth -= D3DXVec3Length(&locvelcomp) * fElapsedTime * 5.0f;
                        if (cloudVisSmooth < cloudVisTarget)
                                cloudVisSmooth = cloudVisTarget;
                }

                viewscreen->alphascreen.a = cloudVisSmooth;
        }
        // this gets inversed down below




        // wind direction smoothing =========================
        // 350 - 010 = 340 ... if  > D3DX_PI then we go DOWN
        // 010 - 350 = -340 ... if < -D3DX_PI then we go UP
        // 240 - 220 = 20  // we go up
        // 220 - 240 = -20
        const float winddiff = winddir - smoothwinddir; // radians
        if (winddiff > D3DX_PI)
        {
                smoothwinddir -= shearRate;
                if (smoothwinddir < 0)
                        smoothwinddir += D3DX_TAU;
        }
        else if (winddiff < -D3DX_PI)
        {
                smoothwinddir += shearRate;
                if (smoothwinddir > D3DX_TAU)
                        smoothwinddir -= D3DX_TAU;
        }
        else if (fabsf(winddiff) > shearRate)
                smoothwinddir += shearRate * copysignf(1.0f, winddiff);
        else
                smoothwinddir = winddir;



        logger->AddToCallStack("TemperatureSmoothingDiff");

        // temperature and winds above 63km
        const float whereWeThinkWeLeaveOffAt63 = -27.89f;
        if (f_MSL >= 63.0f && f_MSL < 80.0f) // server stops sending updates at 63km ... added this filler 5/23/2018
        {
                //63km to 80km we are losing 4.12 per km
                temperature = whereWeThinkWeLeaveOffAt63 - (f_MSL - 63.0f) * 4.12f;
                SetWindspeedKms(0.0f);
                SetTurbulenceScalar(0.0f);
        }
        else if (f_MSL >= 80.0f && f_MSL < 90.0f)
        {
                //80km to 90km constant
                temperature = whereWeThinkWeLeaveOffAt63 - 70.0f;
                SetWindspeedKms(0.0f);
                SetTurbulenceScalar(0.0f);
        }
        else if (f_MSL >= 90.0f) // thermosphere
        {
                temperature = 1006.115f - 1097.39779f / (1.0f + powf(f_MSL / 179.8561f, 9.161937f));
                SetWindspeedKms(0.0f);
                SetTurbulenceScalar(0.0f);
        }

        // == Temperature Smoothing ==
        const float tempdiff = temperature - smoothTemperature;
        smoothTemperature += tempdiff * fElapsedTime * 0.1f;




        // Illumination under clouds --------------------------------------------------------------------
        if (daylightOverride != -1.0f)
                f_temp = daylightOverride;
        else
                f_temp = elevation;

        if (f_temp < 0.05f) // Don't want them to get turned off because they can't see ANYTHING
                f_temp = 0.05f;
        else if (f_temp > 1.0f)
                f_temp = 1.0f;

        // Rain not only reduces visibility but should lower light level
        // https://jira.risetvp.com/view.php?id=422
        // turbidity is 2-16 BCL at 16 (heaviest rain) I would imagine half the light level, 2 is 100%
        f_temp *= sqrtf(1.0f - (GetTurbidity() - 2.0f) / 14.0f) * 0.5f + 0.5f; // modulated with turbidity 1-0.5 logrithmically
        // so at turbidity 2 we get sqrt(1)=1 * .5 is .5 + .5 is 1, perfecto
        // so at turbidity 16 we get sqrt(0)=0 * .5 is 0 + .5 is .5, perfecto
        // so at turbidity 9 we get sqrtf(.5)=.707 * .5 is .353 is .8535, perfecto
        // so at turbidity 3 we get sqrt(0.9286)=0.96363893653172815327029561361547*.5=0.48181946826586407663514780680774+.5=.982, perfecto

        // Brightest it can get // it is intensified a bit to match map brightness of sun
        D3DXCOLOR bcllight;
        bcllight.r = sunrC * f_temp;// 0.9618320611f*f_temp;
        //if (g_bNightVision)
        //      bcllight.g=max(f_temp, 0.5f);
        //else
        bcllight.g = sungC * f_temp;
        bcllight.b = sunbC * f_temp; // 0.9847328244f*f_temp;
        bcllight.a = f_temp;

        if (g_bAboveClouds)
        {
                if (f_ACL <= 0.0f) // In clouds
                {
                        f_temp = 0.8875f + (f_MSL - cloudTopsMslC) / ((f_MSL - f_ACL) - cloudTopsMslC) * 0.1125f; // Percent of height
                }
                else // Above the upper
                {
                        f_temp = 1.0f;
                }
        }
        else
        {
                // what fraction of light is visible?
                if (f_BCL <= 0.0f) // In clouds
                        f_temp = 0.6375f - f_BCL / (cloudTopsMslC - (f_MSL + f_BCL)) * 0.25f; // 0.85 at f_BCL=0 to 0.90 at midcloudlevelC
                else // Below the lower layer
                        f_temp = 1.0f - cloudThickness * 0.05f;// 0.6375f;//1.0f+(f_ACL+f_BCL)*0.05f; // 5% per kilometer
        }

        bcllight *= f_temp;
        // Illumination under clouds --------------------------------------------------------------------


        if (lightningbelow.inuse && !playerships[0].simulator && playerships[0].reference != REF_SIMBAY)
        {
                if (f_ACL < 0.150f)
                {
                        f_temp = lightningbelow.intensity * sqrtf(1.0f - lightningbelow.distance);
                        bcllight.r += 0.7f * f_temp; // 1.0f is closest/brightest/loudest
                        if (bcllight.r > 1.0f)
                                bcllight.r = 1.0f;
                        bcllight.g += 0.7f * f_temp;
                        if (bcllight.g > 1.0f)
                                bcllight.g = 1.0f;
                        bcllight.b += f_temp;
                        if (bcllight.b > 1.0f)
                                bcllight.b = 1.0f;
                }

                lightningbelow.timeleft -= fElapsedTime;
                if (lightningbelow.trend)
                {
                        lightningbelow.intensity += RandomFloat() * fElapsedTime * 50.0f;
                        if (lightningbelow.intensity > 1.0f)
                        {
                                lightningbelow.intensity = 1.0f;
                                if (rand() > 16384)
                                        lightningbelow.trend = false;
                        }
                }
                else
                {
                        lightningbelow.intensity -= RandomFloat() * fElapsedTime * 50.0f;
                        if (lightningbelow.intensity < 0.0f)
                        {
                                lightningbelow.intensity = 0.0f;
                                if (rand() > 16384)
                                        lightningbelow.trend = true;
                                if (lightningbelow.timeleft < 0.0f && lightningbelow.trend)
                                        lightningbelow.inuse = false;
                        }
                }
        }


        for (s = 0; s < ACLlightningC; s++)
        {
                if (lightningabove[s].inuse && !playerships[0].simulator)
                {
                        lightningabove[s].timeleft -= fElapsedTime;
                        if (lightningabove[s].trend)
                        {
                                lightningabove[s].intensity += RandomFloat() * fElapsedTime * 50.0f;
                                if (lightningabove[s].intensity > 1.0f)
                                {
                                        lightningabove[s].intensity = 1.0f;
                                        if (rand() > 16384)
                                                lightningabove[s].trend = false;
                                }
                        }
                        else
                        {
                                lightningabove[s].intensity -= RandomFloat() * fElapsedTime * 50.0f;
                                if (lightningabove[s].intensity < 0.0f)
                                {
                                        lightningabove[s].intensity = 0.0f;
                                        if (rand() > 16384)
                                                lightningabove[s].trend = true;
                                        if (lightningabove[s].timeleft < 0.0f && lightningabove[s].trend)
                                                lightningabove[s].inuse = false;
                                }
                        }
                }
                else if (f_ACL > 0.300f) // !lightningabove[s].inuse
                {
                        lightningabove[s].timeleft = RandomFloat() * 2.0f;
                        lightningabove[s].trend = true;

                        lightningabove[s].panel = static_cast<short>(RandomFloat() * 90.0f) * 25; // Totals 2250
                        lightningabove[s].texture = static_cast<short>(rand()) % 3;

                        lightningabove[s].inuse = true;
                        lightningabove[s].intensity = RandomFloat(); // 1.0f is violent
                }
        }


        // Fireworks
        if (f_ACL < 0.150f)
        {
                float r = 0.0f, g = 0.0f, b = 0.0f, avg = 0.0f;
                for (t = 0; t < fireworksC; t++)
                {
                        if (fireworks[t].inuse)
                        {
                                result = -viewscreen->position - fireworks[t].position;
                                f_temp = D3DXVec3Length(&result) / 20.0f;
                                if (f_temp <= 1.0f)
                                {
                                        f_temp = sqrtf(1.0f - f_temp) * 0.15f;
                                        // in addition it depends on where it is in the sequence
                                        // like dark light dark 
                                        if (fireworks[t].type == 0)
                                                f_temp *= sinf(D3DX_PI * static_cast<float>(fireworks[t].texture) / (firework1C - 1));
                                        else if (fireworks[t].type == 1)
                                                f_temp *= sinf(D3DX_PI * static_cast<float>(fireworks[t].texture) / (firework2C - 1));
                                        else
                                                f_temp *= sinf(D3DX_PI * static_cast<float>(fireworks[t].texture) / (firework3C - 1));
                                        r += fireworks[t].color.r * f_temp;
                                        g += fireworks[t].color.g * f_temp;
                                        b += fireworks[t].color.b * f_temp;
                                        avg++;
                                }
                        }
                }
                if (avg > 0.0f)
                {
                        bcllight.r += r / avg;
                        if (bcllight.r > 1.0f)
                                bcllight.r = 1.0f;
                        bcllight.g += g / avg;
                        if (bcllight.g > 1.0f)
                                bcllight.g = 1.0f;
                        bcllight.b += b / avg;
                        if (bcllight.b > 1.0f)
                                bcllight.b = 1.0f;
                }
        }








        // Horizon color calculation --------------------------------------------------------------------
        if (g_bAboveClouds)
        {
                if (elevation < -0.2f) // below -12° just red
                {
                        colorhorizon.r = 255.0f;
                        colorhorizon.g = colorhorizon.b = 0.0f;
                }
                else if (elevation >= -0.2f && elevation < 0.09f) // -12° to 5° fade to orange
                {
                        colorhorizon.r = 255.0f;
                        colorhorizon.g = (elevation + 0.2f) / 0.29f * 127.5f;
                        colorhorizon.b = 0.0f;
                }
                else if (elevation >= 0.09f && elevation < 0.25f) // 5° to 15° fade to yellow
                {
                        colorhorizon.r = 255.0f - 63.5f * (elevation - 0.09f) / 0.16f; // fade from 255 to 191.5
                        colorhorizon.g = 127.5f + 64.0f * (elevation - 0.09f) / 0.16f; // fade from 128 to 191.5
                        colorhorizon.b = 0.0f;
                }
                else if (elevation >= 0.25f) // above 15° fade to white
                {
                        colorhorizon.r = 191.5f;//255.0f-(elevation-0.25f)/0.75f*63.75f; // runs it to 192
                        colorhorizon.g = 191.5f;//255.0f-(elevation-0.25f)/0.75f*63.75f; // runs it to 192
                        colorhorizon.b = (elevation - 0.25f) / 0.75f * 255.0f; // runs it to 255
                }
                colorhorizon /= 255.0f;
        }
        // Horizon color calculation --------------------------------------------------------------------


        // Zenith color calculations --------------------------------------------------------------------
        if (g_bAboveClouds)
        {
                if (elevation < -0.09f) // Purple
                {
                        colorzenith.r = 100.0f / 255.0f; colorzenith.g = 50.0f / 255.0f; colorzenith.b = 100.0f / 255.0f;
                }
                if (elevation >= -0.09f && elevation < -0.06f) // -5° to -3° turns more red
                {
                        colorzenith.r = 100.0f / 255.0f;
                        colorzenith.g = 50.0f / 255.0f;
                        colorzenith.b = (100.0f - 50.0f * (elevation + 0.09f) / 0.03f) / 255.0f;
                }
                if (elevation >= -0.06f && elevation < -0.02f) // -3° to -1° turns to blue
                {
                        colorzenith.r = (100.0f - 50.0f * (elevation + 0.06f) / 0.04f) / 255.0f;
                        colorzenith.g = 50.0f / 255.0f;
                        colorzenith.b = (50.0f + 50.0f * (elevation + 0.06f) / 0.04f) / 255.0f;
                }
                if (elevation >= -0.02f) // Increasing brightness of blue throughout the day
                {
                        colorzenith.r = colorzenith.g = (50.0f + 50.0f * (elevation + 0.02f) / 1.02f) / 255.0f;
                        colorzenith.b = (100.0f + 100.0f * (elevation + 0.02f) / 1.02f) / 255.0f;
                }
        }
        // Zenith color calculations --------------------------------------------------------------------


        // Interpolate color as we climb up to top of clouds

        //D3DXCOLOR tempcolor;


        //f_temp=elevation;
        //if (f_temp<0.0f)
        //      f_temp=0.0f; // clamped
        //tempcolor = colorhorizon * f_temp;
        //lerp between bcllight and tempcolor?

        // The diffuse light through clouds on city and ground (if normals were available)
        if (daylightOverride == -1.0f)
                viewscreen->sunlight.Diffuse = bcllight;
        else
                viewscreen->sunlight.Diffuse = bcllight * daylightOverride;


        // Inverse
        viewscreen->alphascreen.a = 1.0f - viewscreen->alphascreen.a;


        // Vessel illumination --------------------------------------------------------------------------
        D3DXCOLOR shiplight;

        // Start with exterior hull illumination
        shiplight.r = 0; shiplight.g = 0; shiplight.b = 0; // zeroed out 5/27/2018 looks like Ian is adding hull lights to models now

        int index = 0;
        if (playerships[0].reference == REF_INANOTHER)
                index = playerships[0].inarray;
        if (playerships[index].logolight)
        {
                // so this has revealed that it isn't a simple "max" between two lights...
                // it is additive, 2 flashlights shining on the same spot doubles the brightness
                // problem is we have a finite limit to the brightness unless we go to HDR 
                const short temptype = playerships[index].VB;
                for (s = 0; s < static_cast<short>(polyobjects[temptype].effects.size()); s++)
                {
                        const s_light_effect effect = polyobjects[temptype].effects.at(s);
                        if (effect.sequencing & playerships[index].compare)
                        {
                                if (effect.power == 2.0f)
                                {
                                        if (!playerships[index].headlight)
                                                continue;
                                        f_temp = 0.025f;
                                }
                                else if (effect.power == 1.5f) // rotating lights
                                {
                                        continue;
                                        //if (playerships[index].type == VehicleType::P13)
                                        //{
                                        //      if (!playerships[index].police || !playerships[index].specialight)
                                        //              continue;
                                        //}
                                }
                                else if (effect.power == 0.5f) // strobe
                                        f_temp = 0.075f;
                                else
                                        f_temp = 0.05f; // needs to be set or continue!!
                                
                                shiplight.r += effect.diffuse.r * f_temp;
                                shiplight.g += effect.diffuse.g * f_temp;
                                shiplight.b += effect.diffuse.b * f_temp;
                        }
                }
                if (index == 0)
                        shiplight *= ourcockpit.power;
        }

        D3DXVECTOR4 shipdiff;
        shipdiff.x = shiplight.r; shipdiff.y = shiplight.g; shipdiff.z = shiplight.b; shipdiff.w = 0; // unused but could be viewscreen->alphascreen.a;
        // ReSharper disable once CppJoinDeclarationAndAssignment
        V(viewscreen->gameclass->graphics->g_pEffect->SetVector("shiplight", &shipdiff));

        // Reflection of our light based on turbidity
        f_temp = sqrtf(bcllight.r * bcllight.r + bcllight.g * bcllight.g + bcllight.b * bcllight.b);
        if (f_temp > 1.0f)
                f_temp = 1.0f;
        f_temp = (1.0f - f_temp) * 0.5f;

        // Vessel illumination --------------------------------------------------------------------------



        // Find our alphascreen color
        if (f_ACL <= 0.150f)
        {
                f_temp *= 1.0f - Clamp(sqrtf(fFogEndHorizon / 0.4f), 0, 1);
                viewscreen->alphascreen.r = Clamp(bcllight.r + f_temp * shiplight.r, 0, 1);
                viewscreen->alphascreen.g = Clamp(bcllight.g + f_temp * shiplight.g, 0, 1);
                viewscreen->alphascreen.b = Clamp(bcllight.b + f_temp * shiplight.b, 0, 1);
        }

        // Reduce visibility by 1/2 when sun in view (flare)
        if (f_ACL > 0.0f)
        {
                shadow = viewscreen->ProbeBoundSphere(&playerships[0].position, &Xsunlight);
                if (inview > 0.0f)
                {
                        f_temp = inview * shadow;
                        betascreen.r = sunrC * f_temp;
                        betascreen.g = sungC * f_temp;
                        betascreen.b = sunbC * f_temp;
                        betascreen.a = f_temp;
                }
                else
                {
                        betascreen.a = betascreen.r = betascreen.g = betascreen.b = 0.0f;
                }
        }
        else
        {
                betascreen.a = betascreen.r = betascreen.g = betascreen.b = shadow = 0.0f;
        }



        // Horizon and Zenith -------------------------------------------------------------------------
        dwFogColorHorizon = bcllight;




        // Ambient light scattered by the atmosphere
//      scatter.r=r/714.0f; scatter.g=g/714.0f; scatter.b=b/714.0f; // Based on middle radius sunmap.bmp


        cloudHorizonAngle = D3DX_HALFPI - acosf(cloudTopsRadiusC / (f_MSL + radiusC));
        cloudHorizonDistance = cloudTopsRadiusC / tanf(cloudHorizonAngle); // distance to horizon 1b or 2c
        if (cloudHorizonDistance < 256.0f)
                cloudHorizonDistance = 256.0f;


        // here is where we will play with the visibility 10m to 400m in the clouds
        if (f_ACL < 0.150f && f_BCL < 0.150f) // ACL is above upper cloud level, BCL is below cloud bases)
        {
                static float cloudVisTarget1 = RandomFloat();
                static float cloudVisSmooth1 = RandomFloat();

                // Speed at which we arrive at new target is based on our tangent
                if (cloudVisSmooth1 < cloudVisTarget1)
                {
                        cloudVisSmooth1 += D3DXVec3Length(&locvelcomp) * fElapsedTime * 10.0f;
                        if (cloudVisSmooth1 > cloudVisTarget1)
                                cloudVisSmooth1 = cloudVisTarget1;
                }
                else if (cloudVisSmooth1 > cloudVisTarget1)
                {
                        cloudVisSmooth1 -= D3DXVec3Length(&locvelcomp) * fElapsedTime * 10.0f;
                        if (cloudVisSmooth1 < cloudVisTarget1)
                                cloudVisSmooth1 = cloudVisTarget1;
                }
                if (cloudVisTarget1 == cloudVisSmooth1)
                {
                        // should side on 400 at turbidity 2 ... 14 is on the 10 meter side ... maybe to 20 meters?
                        const float targetSpectrum = (GetTurbidity() - 2.0f) / 12.0f;
                        const float fluctuate = 1.0f - GetTurbidity() / 20.0f; // 0.1 to 0.7
                        if (rand() % 2)
                                cloudVisTarget1 = Clamp(targetSpectrum + RandomFloat() * fluctuate, 0, 1);
                        else
                                cloudVisTarget1 = Clamp(targetSpectrum - RandomFloat() * fluctuate, 0, 1);
                }

                if (playerships[0].reference != REF_INANOTHER || playerships[playerships[0].inarray].baydoor)
                        fFogEndHorizon = Lerp(168.64f / powf(GetTurbidity(), 2.0f), 0.400f - 0.390f * cloudVisSmooth1, viewscreen->alphascreen.a);
                else
                        fFogEndHorizon = 168.64f / powf(GetTurbidity(), 2.0f);
        }
        else
        {
                fFogEndHorizon = 168.64f / powf(GetTurbidity(), 2.0f);
        }


        if (alphascreenOverride == 1.0f)
        {
                if (playerships[0].reference != REF_INANOTHER || playerships[playerships[0].inarray].baydoor)
                        fFogEndHorizon = 0.400f;
                else
                        fFogEndHorizon = 42.16f;
                viewscreen->alphascreen.a = alphascreenOverride;
        }
        else if (alphascreenOverride == 0.0f)
        {
                fFogEndHorizon = 42.16f;
                viewscreen->alphascreen.a = alphascreenOverride;
        }


        if (g_bAboveClouds)
        {
                f_temp = f_MSL / (ScaleHeightC * 6.0f); // was 9 until 8/10/2019 so we get blackness sooner
                if (f_temp > 1.0f)
                        f_temp = 1.0f;
                else if (f_temp < 0.0f)
                        f_temp = 0.0f;
                f_temp = sqrtf(1.0f - f_temp);
                if (elevation<0.0f && elevation>-0.09f)
                        f_temp *= (elevation + 0.09f) / 0.09f; // Time of day adjustment
                if (elevation <= -0.09f)
                        f_temp = 0.01f;

                colorzenith.a = f_temp;
                // for static stars, Iomere, sun blend
                D3DXColorLerp(&colorzenith, &colorzenith, &viewscreen->alphascreen, viewscreen->alphascreen.a);
                dwFogFactorZenith = colorzenith;

                colorzenith.a = 1.0f;
                colorzenith.r *= dwFogFactorZenith.a;
                //      if (g_bNightVision)
                //              colorzenith.g*=max(f_temp,0.5f);
                //      else
                colorzenith.g *= dwFogFactorZenith.a;
                colorzenith.b *= dwFogFactorZenith.a;
                //  for skyring and Iomere and ambient darkness
                dwFogColorZenith = colorzenith;
        }
        else
        {
                dwFogFactorZenith = dwFogColorZenith = 0UL;
        }

        // End of fog calculations ----------------------------------------------------------------------

        logger->AddToCallStack("weather::FrameMove END");
}

void weather::SetWindDirectionRadians(float prmWinddir)
{
        winddir = prmWinddir;
        if (smoothwinddir == -1.0f)
        {
                smoothwinddir = winddir;
                logger->Log("Weather1 initialized smoothwinddir!");
        }
}

void weather::SetTurbulenceScalar(float prmTurbulence)
{
        turbulence = prmTurbulence;
}

void weather::SetTemperatureCelsius(float prmTemperature)
{
        temperature = prmTemperature;
        if (smoothTemperature == -1.0f)
        {
                smoothTemperature = temperature;
                logger->Log("Weather1 initialized smoothTemperature!");
        }
}

void weather::SetWindspeedKms(float prmWindspeed)
{
        windspeed = prmWindspeed;
}

void weather::SetTurbidity(float prmTurbidity)
{
        turbidity = prmTurbidity;
        if (smoothTurbidity == -1.0f)
        {
                smoothTurbidity = turbidity;
                logger->Log("Weather1 initialized smoothVisibility!");
        }
}

void weather::SetCloudSurfaceTargetKm(float prmCloudSurfaceTargetKm)
{
        cloudSurfaceTargetKm = prmCloudSurfaceTargetKm;
        if (cloudSurfaceSmoothKm == -1.0f)
        {
                cloudSurfaceSmoothKm = cloudSurfaceTargetKm;
                logger->Log("Weather2 initialized cloudSurfaceSmoothKm!");
        }
}

void weather::SetCloudCeilingTargetKm(float prmCloudCeilingTargetKm)
{
        cloudCeilingTargetKm = prmCloudCeilingTargetKm;
        if (cloudCeilingSmoothAglKm == -1.0f)
        {
                cloudCeilingSmoothAglKm = cloudCeilingTargetKm;
                logger->Log("Weather2 initialized cloudCeilingSmoothKm!");
        }
}

void weather::InitializeSmoothValues()
{
        smoothwinddir = -1.0f;
        smoothTemperature = -1.0f;
        cloudSurfaceSmoothKm = -1.0f;
        cloudCeilingSmoothAglKm = -1.0f;
}

float weather::GetWindspeedKms() const
{
        if (!playerships[0].simulator)
                return windspeed;
        return 0.0f;
}

float weather::GetTurbidity() const
{
        if (!playerships[0].simulator)
                return smoothTurbidity;
        return 2.0f;
}

float weather::GetWindDirectionRadians() const
{
        if (!playerships[0].simulator)
                return winddir;
        return 0.0f;
}

float weather::GetTurbulence() const
{
        if (!playerships[0].simulator)
                return turbulence;
        return 0.0f;
}

float weather::GetTemperatureCelsius() const
{
        if (!playerships[0].simulator)
                return smoothTemperature;
        return 20.0f;
}

float weather::GetCloudCeilingMslKm() const
{
        if (!playerships[0].simulator)
                return cloudSurfaceSmoothKm + cloudCeilingSmoothAglKm;
        return f_MSL - f_AGL + 1.8f;
}