#include "Spinner.h"

 #include "UIModSelectorModButton.h"

 ConVar osu_pvs("osu_pvs", true, FCVAR_DEFAULT,

                "optimizes all loops over all hitobjects by clamping the range to the Potentially Visible Set");

 ConVar osu_draw_hitobjects("osu_draw_hitobjects", true, FCVAR_DEFAULT);

                            osu->getScore()->getModsLegacy(), getAR(), getCS(), getOD(), osu->getSpeedMultiplier());

         }

     }

 }

 void Beatmap::deselect() {

         // if it's not a stream then we are loading the entire song into memory for playing

         if(!stream) engine->getResourceManager()->requestNextLoadAsync();

         m_music->setVolume(getIdealVolume());

         m_fMusicFrequencyBackup = m_music->getFrequency();

         m_music->setSpeed(osu->getSpeedMultiplier());

     // 0.7x means animation lasts only 0.7 of it's time

     const double animationMutiplier = osu->getSpeedMultiplier() / osu->getAnimationSpeedMultiplier();

     const long followPointApproachTime =

     const bool followPointsConnectCombos = osu_followpoints_connect_combos.getBool();

     const bool followPointsConnectSpinners = osu_followpoints_connect_spinners.getBool();

     const float followPointSeparationMultiplier = max(osu_followpoints_separation_multiplier.getFloat(), 0.1f);

                        m_hitobjects[0]->getTime() > (long)osu_quick_retry_time.getInt())

                         m_music->setPositionMS(

                             max((long)0, m_hitobjects[0]->getTime() - (long)osu_quick_retry_time.getInt()));

                     m_bIsRestartScheduledQuick = false;

             (bancho.is_playing_a_multi_map() && !bancho.room.all_players_loaded));

 }

 Vector2 Beatmap::pixels2OsuCoords(Vector2 pixelCoords) const {

     // un-first-person

     bool isComplete = (num300s + num100s + num50s + numMisses >= numHitObjects);

     bool isZero = (osu->getScore()->getScore() < 1);

     bool isCheated = (osu->getModAuto() || (osu->getModAutopilot() && osu->getModRelax())) ||

     FinishedScore score;

     score.isLegacyScore = false;

 #include "Resource.h"

 #include "pp.h"

 class Beatmap;

 class HitObject;

 #include "DifficultyCalculator.h"

 #include "Beatmap.h"

 #include "Replay.h"

 #include "SliderCurves.h"

 ConVar osu_stars_xexxar_angles_sliders("osu_stars_xexxar_angles_sliders", true, FCVAR_DEFAULT,

                                        "completely enables/disables the new star/pp calc algorithm");

 ConVar osu_stars_slider_curve_points_separation(

                     double speed_bonus = 1.0;

                     if(strain_time < min_speed_bonus)

                     // https://github.com/ppy/osu/blob/master/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs

                     int previousIslandSize = 0;

                         currHistoricalDecay =

                             min((double)(historicalNoteCount - i) / historicalNoteCount,

                         double currDelta = currObj->strain_time;

                         double prevDelta = prevObj->strain_time;

                         double lastDelta = lastObj->strain_time;

                         double currRatio =

                         windowPenalty = min(1.0, windowPenalty);

                         return 0.0;

                     auto calcWideAngleBonus = [](double angle) {

                     };

                     auto calcAcuteAngleBonus = [=](double angle) { return 1.0 - calcWideAngleBonus(angle); };

                                        min(angleBonus, 125.0 / strain_time) *

                                        pow(std::sin(PI / 2.0 * min(1.0, (100.0 - strain_time) / 25.0)), 2.0) *

                                        pow(std::sin(PI / 2.0 * (clamp<double>(jumpDistance, 50.0, 100.0) - 50.0) /

                             wideAngleBonus *=

                         }

                     }

                         currVelocity = (jumpDistance + prev.travelDistance) / strain_time;

                         double distRatio = pow(std::sin(PI / 2.0 * std::abs(prevVelocity - currVelocity) /

                         velocityChangeBonus =

                             overlapVelocityBuff * distRatio *

                     }

                     if(prev.ho->type == OsuDifficultyHitObject::TYPE::SLIDER)

                         sliderBonus = prev.travelDistance / prev.travelTime;

                     if(withSliders) aimStrain += sliderBonus * slider_multiplier;

                     return aimStrain;

                         (prev1.ho->curve ? prev1.ho->curve->pointAt(prev1.ho->repeats % 2 ? 1.0 : 0.0) : prev1.ho->pos)

                             .distance(cur.ho->pos) *

                         radius_scaling_factor;

                 }

                 // calculate angles

     double multiplier = 1.14;  // keep final pp normalized across changes

     {

         if(modsLegacy & ModFlags::NoFail)

         if((modsLegacy & ModFlags::SpunOut) && score.totalHits > 0)

             multiplier *= 1.0 - pow((double)numSpinners / (double)score.totalHits,

         if((modsLegacy & ModFlags::Relax) && !osu_stars_and_pp_lazer_relax_autopilot_nerf_disabled.getBool()) {

             double okMultiplier = max(0.0, od > 0.0 ? 1.0 - pow(od / 13.33, 1.8) : 1.0);   // 100

     const double accuracyValue = computeAccuracyValue(score, attributes);

     const double totalValue =

     return totalValue;

 }

 double DifficultyCalculator::calculateTotalStarsFromSkills(double aim, double speed) {

     double baseAimPerformance = pow(5.0 * max(1.0, aim / 0.0675) - 4.0, 3.0) / 100000.0;

     double baseSpeedPerformance = pow(5.0 * max(1.0, speed / 0.0675) - 4.0, 3.0) / 100000.0;

     return basePerformance > 0.00001

                ? 1.04464392682 /* Math.Cbrt(OsuPerformanceCalculator.PERFORMANCE_BASE_MULTIPLIER) */ * 0.027 *

                      (std::cbrt(100000.0 / pow(2.0, 1 / 1.1) * basePerformance) + 4.0)

     // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of

     // misses.

     if(effectiveMissCount > 0 && score.totalHits > 0)

     // combo scaling

     if(score.beatmapMaxCombo > 0)

     // ar bonus

     double approachRateFactor = 0.0;  // see https://github.com/ppy/osu-performance/pull/125/

     // hidden

     if(score.modsLegacy & ModFlags::Hidden)

         aimValue *= 1.0 + 0.04 * (max(12.0 - attributes.ApproachRate,

     // "We assume 15% of sliders in a map are difficult since there's no way to tell from the performance calculator."

     double estimateDifficultSliders = attributes.SliderCount * 0.15;

     if(attributes.SliderCount > 0) {

         aimValue *= sliderNerfFactor;

     }

     // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of

     // misses.

     if(effectiveMissCount > 0 && score.totalHits > 0)

     // combo scaling

     if(score.beatmapMaxCombo > 0)

     // ar bonus

     double approachRateFactor = 0.0;  // see https://github.com/ppy/osu-performance/pull/125/

     // hidden

     if(score.modsLegacy & ModFlags::Hidden)

         speedValue *= 1.0 + 0.04 * (max(12.0 - attributes.ApproachRate,

     // "Calculate accuracy assuming the worst case scenario"

     double relevantTotalDiff = score.totalHits - attributes.SpeedNoteCount;

     // see https://github.com/ppy/osu-performance/pull/128/

     // Scale the speed value with accuracy and OD

     // Scale the speed value with # of 50s to punish doubletapping.

     speedValue *=

         pow(0.99, score.countMeh < (score.totalHits / 500.0) ? 0.0 : score.countMeh - (score.totalHits / 500.0));

     if(betterAccuracyPercentage < 0.0) betterAccuracyPercentage = 0.0;

     // arbitrary values tom crafted out of trial and error

     // length bonus

     accuracyValue *= min(1.15, pow(score.amountHitObjectsWithAccuracy / 1000.0, 0.3));

 #include "GameRules.h"

 ConVar GameRules::osu_playfield_border_top_percent("osu_playfield_border_top_percent", 0.117f, FCVAR_DEFAULT);

 ConVar GameRules::osu_playfield_border_bottom_percent("osu_playfield_border_bottom_percent", 0.0834f, FCVAR_DEFAULT);

     static float getRawHitCircleDiameter(float CS, bool applyBrokenGamefieldRoundingAllowance = true) {

         return max(0.0f,

     }

     static float getHitCircleXMultiplier() {

     static ConVar osu_playfield_border_top_percent;

     static ConVar osu_playfield_border_bottom_percent;

     static float getPlayfieldScaleFactor() {

         const int engineScreenWidth = osu->getScreenWidth();

 #include "VertexArrayObject.h"

 #include "score.h"

 ConVar osu_automatic_cursor_size("osu_automatic_cursor_size", false, FCVAR_DEFAULT);

 ConVar osu_cursor_alpha("osu_cursor_alpha", 1.0f, FCVAR_DEFAULT);

     const float normalizedHeight = osu->getSkin()->getCursorRipple()->getHeight() * normalized2xScale * imageScale;

     const float duration = max(osu_cursor_ripple_duration.getFloat(), 0.0001f);

     if(osu_cursor_ripple_additive.getBool()) g->setBlendMode(Graphics::BLEND_MODE::BLEND_MODE_ADDITIVE);

 #include "HitObject.h"

 #include "AnimationHandler.h"

 #include "Skin.h"

 #include "SkinImage.h"

 ConVar osu_hitresult_draw_300s("osu_hitresult_draw_300s", false, FCVAR_DEFAULT);

 ConVar osu_hitresult_scale("osu_hitresult_scale", 1.0f, FCVAR_DEFAULT);

         // hitobject body fadein

         const long fadeInStart = m_iTime - m_iApproachTime;

         const long fadeInEnd =

         m_fAlpha = clamp<float>(1.0f - ((float)(fadeInEnd - curPos) / (float)(fadeInEnd - fadeInStart)), 0.0f, 1.0f);

         m_fAlphaWithoutHidden = m_fAlpha;

         const long approachCircleFadeStart = m_iTime - m_iApproachTime;

         const long approachCircleFadeEnd =

             min(m_iTime, m_iTime - m_iApproachTime +

         m_fAlphaForApproachCircle = clamp<float>(

             1.0f - ((float)(approachCircleFadeEnd - curPos) / (float)(approachCircleFadeEnd - approachCircleFadeStart)),

             0.0f, 1.0f);

 #include "UpdateHandler.h"

 #include "VertexArrayObject.h"

 UString MainMenu::NEOSU_MAIN_BUTTON_TEXT = UString("neosu");

 UString MainMenu::NEOSU_MAIN_BUTTON_SUBTEXT = UString("Multiplayer Client");

         if(t.beatLengthBase == 0.0f)  // bah

             t.beatLengthBase = 1.0f;

         pulse = (float)((curMusicPos - t.offset) % max((long)t.beatLengthBase, (long)1)) /

                 t.beatLengthBase;  // modulo must be >= 1

         pulse = clamp<float>(pulse, -1.0f, 1.0f);

         const float randomDuration2 = (static_cast<float>(rand()) / static_cast<float>(RAND_MAX)) * 3.5f;

         const float randomDuration3 = (static_cast<float>(rand()) / static_cast<float>(RAND_MAX)) * 3.5f;

         anim->moveQuadOut(&m_fMainMenuAnim1, m_fMainMenuAnim1Target, 1.5f + randomDuration1);

         anim->moveQuadOut(&m_fMainMenuAnim2, m_fMainMenuAnim2Target, 1.5f + randomDuration2);

         anim->moveQuadOut(&m_fMainMenuAnim3, m_fMainMenuAnim3Target, 1.5f + randomDuration3);

 #include "UISearchOverlay.h"

 #include "UISlider.h"

 ConVar osu_options_save_on_back("osu_options_save_on_back", true, FCVAR_DEFAULT);

 ConVar osu_options_high_quality_sliders("osu_options_high_quality_sliders", false, FCVAR_DEFAULT);

 ConVar osu_options_slider_preview_use_legacy_renderer(

     const float categoriesOptionsPercent = 0.135f;

     int optionsWidth = (int)(osu->getScreenWidth() * optionsScreenWidthPercent);

     const int categoriesWidth = optionsWidth * categoriesOptionsPercent;

 #include "VolumeOverlay.h"

 #include "score.h"

 Osu *osu = NULL;

 // release configuration

 ConVar instant_replay_duration("instant_replay_duration", 15.f, FCVAR_DEFAULT,

                                "instant replay (F2) duration, in seconds");

 ConVar normalize_loudness("normalize_loudness", false, FCVAR_DEFAULT, "normalize loudness across songs");

 ConVar use_https("use_https", true, FCVAR_DEFAULT);

 ConVar mp_server("mp_server", "ez-pp.farm", FCVAR_DEFAULT);

                     getImageScaleToFitResolution(m_backBuffer->getSize(), engine->getGraphics()->getResolution());

                 const float scaledWidth = m_backBuffer->getWidth() * scale;

                 const float scaledHeight = m_backBuffer->getHeight() * scale;

             } else {

                 m_backBuffer->draw(g, 0, 0, engine->getGraphics()->getResolution().x,

                                    engine->getGraphics()->getResolution().y);

         // disable internal resolution on specific conditions

         bool windowsBorderlessHackCondition =

              (int)g_vInternalResolution.y == (int)env->getNativeScreenSize().y);  // HACKHACK

         if(((int)g_vInternalResolution.x == engine->getScreenWidth() &&

             (int)g_vInternalResolution.y == engine->getScreenHeight()) ||

 #include "SoundEngine.h"

 #include "VolumeOverlay.h"

 #define OSU_BITMASK_HITWHISTLE 0x2

 #define OSU_BITMASK_HITFINISH 0x4

 #define OSU_BITMASK_HITCLAP 0x8

 #include "SkinImage.h"

 #include "ConVar.h"

 #include "ResourceManager.h"

 #include "Skin.h"

 ConVar osu_skin_animation_fps_override("osu_skin_animation_fps_override", -1.0f, FCVAR_DEFAULT);

 ConVar *SkinImage::m_osu_skin_mipmaps_ref = NULL;

         // the beatmap (m_iBeatmapTimeAnimationStartOffset), and we need the beatmap time (curMusicPos) as a relative

         // base m_iBeatmapAnimationTimeStartOffset must be set by all hitobjects live while drawing (e.g. to their

         // m_iTime-m_iObjectTime), since we don't have any animation state saved in the hitobjects!

         m_iFrameCounterUnclamped = m_iFrameCounter;

         m_iFrameCounter = m_iFrameCounter % m_images.size();  // clamp and wrap around to the number of frames we have

     }

 #include "cbase.h"

 class Skin;

                                         // depending on the diameter defined by the CS)

     virtual void update(float speedMultiplier, bool useEngineTimeForAnimations = true, long curMusicPos = 0);

     void setAnimationTimeOffset(float speedMultiplier,

                                 long offset);  // set this every frame (before drawing) to a fixed point in time

                                                // relative to curMusicPos where we become visible

     float m_fDrawClipWidthPercent;

     std::vector<std::string> m_filepathsForExport;

 };

 #include "SoundEngine.h"

 #include "VertexArrayObject.h"

 ConVar osu_slider_ball_tint_combo_color("osu_slider_ball_tint_combo_color", true, FCVAR_DEFAULT);

 ConVar osu_snaking_sliders("osu_snaking_sliders", true, FCVAR_DEFAULT);

                                  1.0f - m_fEndSliderBodyFadeAnimation, getTime());

     }

         float alpha = 1.0f - m_fStartHitAnimation;

         float scale = m_fStartHitAnimation;

         // fade out over the duration of the slider, starting exactly when the default fadein finishes

         const long hiddenSliderBodyFadeOutStart =

         const float fade_percent = osu_mod_hd_slider_fade_percent.getFloat();

         const long hiddenSliderBodyFadeOutEnd = m_iTime + (long)(fade_percent * m_fSliderTime);

         if(curPos >= hiddenSliderBodyFadeOutStart) {

         // (for the end of the slider) is NOT checked at the exact end of the slider, but somewhere random before,

         // because fuck you

         const long offset = (long)osu_slider_end_inside_check_offset.getInt();

         const bool isTrackingCorrectly = (isClickHeldSlider() || osu->getModRelax()) && m_bCursorInside;

         if(isTrackingCorrectly) {

             if(isTrackingStrictTrackingMod) {

 #include "SliderCurves.h"

 #include "ConVar.h"

 #include "Engine.h"

 ConVar osu_slider_curve_points_separation(

     "osu_slider_curve_points_separation", 2.5f, FCVAR_LOCKED,

     "slider body curve approximation step width in osu!pixels, don't set this lower than around 1.5");

 #include "Skin.h"

 #include "VertexArrayObject.h"

 Shader *SliderRenderer::BLEND_SHADER = NULL;

 float SliderRenderer::MESH_CENTER_HEIGHT =

 #include "Skin.h"

 #include "SoundEngine.h"

 ConVar osu_songbrowser_button_active_color_a("osu_songbrowser_button_active_color_a", 220 + 10, FCVAR_DEFAULT);

 ConVar osu_songbrowser_button_active_color_r("osu_songbrowser_button_active_color_r", 255, FCVAR_DEFAULT);

 ConVar osu_songbrowser_button_active_color_g("osu_songbrowser_button_active_color_g", 255, FCVAR_DEFAULT);

 #include "Skin.h"

 #include "UIContextMenu.h"

 ConVar osu_songbrowser_button_collection_active_color_a("osu_songbrowser_button_collection_active_color_a", 255,

                                                         FCVAR_DEFAULT);

 ConVar osu_songbrowser_button_collection_active_color_r("osu_songbrowser_button_collection_active_color_r", 163,

 #include "Skin.h"

 #include "Timer.h"

 ConVar osu_songbrowser_button_difficulty_inactive_color_a("osu_songbrowser_button_difficulty_inactive_color_a", 255,

                                                           FCVAR_DEFAULT);

 ConVar osu_songbrowser_button_difficulty_inactive_color_r("osu_songbrowser_button_difficulty_inactive_color_r", 0,

 #include "Spinner.h"

 #include "AnimationHandler.h"

 #include "Skin.h"

 #include "SoundEngine.h"

 ConVar osu_spinner_use_ar_fadein(

     "osu_spinner_use_ar_fadein", false, FCVAR_DEFAULT,

     "whether spinners should fade in with AR (same as circles), or with hardcoded 400 ms fadein time (osu!default)");

 #include "Skin.h"

 #include "SkinImage.h"

 UIBackButton::UIBackButton(float xPos, float yPos, float xSize, float ySize, UString name)

     : CBaseUIButton(xPos, yPos, xSize, ySize, name, "") {

     m_fAnimation = 0.0f;

 #include "Skin.h"

 #include "TooltipOverlay.h"

 UIButton::UIButton(float xPos, float yPos, float xSize, float ySize, UString name, UString text)

     : CBaseUIButton(xPos, yPos, xSize, ySize, name, text) {

     m_bDefaultSkin = false;

 #include "Skin.h"

 #include "SoundEngine.h"

 UIPauseMenuButton::UIPauseMenuButton(std::function<Image *()> getImageFunc, float xPos, float yPos, float xSize,

                                      float ySize, UString name)

     : CBaseUIButton(xPos, yPos, xSize, ySize, name) {

 }

 void UpdateHandler::checkForUpdates() {

     if(env->getOS() != Environment::OS::WINDOWS) return;  // only windows gets releases right now

     m_updateThread = new std::thread(UpdateHandler::run, (void *)this);

         int mainDirectoryOffset = files[i].find(mainDirectory);

         if(mainDirectoryOffset == 0 && files[i].length() - mainDirectoryOffset > 0 &&

             std::string outFilePath = files[i].substr(mainDirectoryOffset + mainDirectory.length());

             // .exe and .dll can't be directly overwritten on windows

             if(outFilePath.length() > 4) {

                     std::string old_path = outFilePath;

                     old_path.append(".old");

                     env->deleteFile(old_path);

     mz_zip_reader_end(&zip_archive);

     m_status = STATUS::STATUS_SUCCESS_INSTALLATION;

     env->deleteFile(zipFilePath);

 }

 #include "TooltipOverlay.h"

 #include "UIAvatar.h"

 // NOTE: selected username is stored in m_sText

 ConVar osu_user_draw_pp("osu_user_draw_pp", true, FCVAR_DEFAULT);

 #include "Replay.h"

 #include "RoomScreen.h"

 ConVar osu_hiterrorbar_misses("osu_hiterrorbar_misses", true, FCVAR_DEFAULT);

 ConVar osu_debug_pp("osu_debug_pp", false, FCVAR_DEFAULT);

 void LiveScore::addHitResult(Beatmap *beatmap, HitObject *hitObject, HIT hit, long delta, bool ignoreOnHitErrorBar,

                              bool hitErrorBarOnly, bool ignoreCombo, bool ignoreScore) {

     // handle hits (and misses)

     if(hit != LiveScore::HIT::HIT_MISS) {

     // add hitValue to score, recalculate score v1

     const unsigned long breakTimeMS = beatmap->getBreakDurationTotal();

     const unsigned long drainLength =

     const int difficultyMultiplier = (int)std::round(

         (beatmap->getSelectedDifficulty2()->getCS() + beatmap->getSelectedDifficulty2()->getHP() +

          beatmap->getSelectedDifficulty2()->getOD() +

 #include "AnimationHandler.h"

 #include "ConVar.h"

 #include "Engine.h"

 ConVar debug_anim("debug_anim", false, FCVAR_DEFAULT);

 AnimationHandler *anim = NULL;

 float AnimationHandler::getRemainingDuration(float *base) const {

     for(size_t i = 0; i < m_vAnimations.size(); i++) {

         if(m_vAnimations[i].m_fBase == base)

     }

     return 0.0f;

 #include "Keyboard.h"

 #include "Mouse.h"

 #include "NetworkHandler.h"

 #include "Profiler.h"

 #include "ResourceManager.h"

 #include "SoundEngine.h"

 #include "VisualProfiler.h"

 #include "XInputGamepad.h"

 class EngineLoadingScreenApp : public App {

    public:

 #include "Mouse.h"

 #include "ConVar.h"

 #include "Environment.h"

 #include "ResourceManager.h"

 ConVar debug_mouse("debug_mouse", false, FCVAR_LOCKED);

 ConVar mouse_sensitivity("mouse_sensitivity", 1.0f, FCVAR_DEFAULT);

     // first person games which call engine->getMouse()->setPos() every frame to manually re-center the cursor NEVER

     // need env->setPos() absolute input NEVER needs env->setPos() also update prevOsMousePos

     if(windowRect.contains(osMousePos) && (sensitivityAdjustmentNeeded || mouse_raw_input.getBool()) &&

     {

         const Vector2 newOsMousePos = m_vPosWithoutOffset;

 #define WINVER 0x0A00  // Windows 10, to enable the ifdefs in winuser.h for touch

 #endif

 #include <dwmapi.h>

 // NEXTRAWINPUTBLOCK macro requires this

 typedef uint64_t QWORD;

 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {

 #ifdef _MSC_VER

     // When building with MSVC, vprintf() is not returning the correct value unless we have a console allocated.

 #ifdef _DEBUG

     AllocConsole();

     freopen_s(&dummy, "CONOUT$", "w", stdout);

             }

         }

         // update

         {

             deltaTimer->update();

 #ifdef __linux__

 #include "LinuxEnvironment.h"

 #include "LinuxContextMenu.h"

 #include "LinuxGLLegacyInterface.h"

 typedef struct {

     unsigned long flags;

     unsigned long functions;

 #ifdef _WIN32

 #include "WinEnvironment.h"

 #include <Lmcons.h>

 #include <Shlobj.h>

 #include <shellapi.h>

 #include <filesystem>

 #include <string>

 #include "WinContextMenu.h"

 #include "WinGL3Interface.h"

 #include "WinGLLegacyInterface.h"

 bool g_bCursorVisible = true;

     std::wstring buffer;

     std::vector<std::string> folders;

     std::wstring wfolder(size, 0);

     MultiByteToWideChar(CP_UTF8, 0, folder.c_str(), folder.length(), (LPWSTR)wfolder.c_str(), wfolder.length());

 #include "OpenGL3Interface.h"

 #ifdef MCENGINE_FEATURE_OPENGL

 #include "OpenGLRenderTarget.h"

 #include "OpenGLShader.h"

 OpenGL3Interface::OpenGL3Interface() : Graphics() {

     // renderer

     m_bInScene = false;

 #include "OpenGL3VertexArrayObject.h"

 #ifdef MCENGINE_FEATURE_OPENGL

 #include "OpenGL3Interface.h"

 #include "OpenGLHeaders.h"

 OpenGL3VertexArrayObject::OpenGL3VertexArrayObject(Graphics::PRIMITIVE primitive, Graphics::USAGE_TYPE usage,

                                                    bool keepInSystemMemory)

     : VertexArrayObject(primitive, usage, keepInSystemMemory) {

 #include "OpenGLVertexArrayObject.h"

 #ifdef MCENGINE_FEATURE_OPENGL

 #include "Engine.h"

 #include "OpenGLHeaders.h"

 ConVar r_opengl_legacy_vao_use_vertex_array(

     "r_opengl_legacy_vao_use_vertex_array", false, FCVAR_LOCKED,

     "dramatically reduces per-vao draw calls, but completely breaks legacy ffp draw calls (vertices work, but "

 #include "Environment.h"

 #include "Timer.h"

 static std::mutex g_resourceManagerMutex;             // internal lock for nested async loads

 static std::mutex g_resourceManagerLoadingWorkMutex;  // work vector lock across all threads

     return fnt;

 }

     // check if it already exists

     if(resourceName.length() > 0) {

         Resource *temp = checkIfExistsAndHandle(resourceName);

                 work.threadIndex = MobileAtomicSizeT(threadIndex);

                 work.done = MobileAtomicBool(false);

                 g_resourceManagerLoadingWorkMutex.lock();

                 {

 #include "ResourceManager.h"

 #include "SoundEngine.h"

 ConVar snd_play_interp_duration(

     "snd_play_interp_duration", 0.75f, FCVAR_DEFAULT,

     "smooth over freshly started channel position jitter with engine time over this duration in seconds");

     // On Windows, we need to convert the UTF-8 path to UTF-16, or paths with unicode characters will fail to open

     int size = MultiByteToWideChar(CP_UTF8, 0, m_sFilePath.c_str(), m_sFilePath.length(), NULL, 0);

     std::wstring file_path(size, 0);

 #else

     std::string file_path = m_sFilePath;

 #endif

     }

 }