From e60024f0afecb6f92e383221084f1a7af02f8542 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 29 Mar 2022 15:41:00 -0500
Subject: SL-17005 WIP - Use D3D/DXGI to query for available VRAM on Windows

---
 indra/llwindow/CMakeLists.txt     |   2 +
 indra/llwindow/llwindow.h         |   3 +
 indra/llwindow/llwindowheadless.h |   2 +
 indra/llwindow/llwindowwin32.cpp  | 136 ++++++++++++++++++++++++++++++++++++++
 indra/llwindow/llwindowwin32.h    |   4 +-
 5 files changed, 146 insertions(+), 1 deletion(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/CMakeLists.txt b/indra/llwindow/CMakeLists.txt
index 70eb99c86c..32f0fa14c4 100644
--- a/indra/llwindow/CMakeLists.txt
+++ b/indra/llwindow/CMakeLists.txt
@@ -145,6 +145,8 @@ if (WINDOWS)
   list(APPEND llwindow_LINK_LIBRARIES
        comdlg32     # Common Dialogs for ChooseColor
        ole32
+       dxgi
+       d3d9
        )
 endif (WINDOWS)
 
diff --git a/indra/llwindow/llwindow.h b/indra/llwindow/llwindow.h
index 0edf39f6ef..507e6076d6 100644
--- a/indra/llwindow/llwindow.h
+++ b/indra/llwindow/llwindow.h
@@ -163,6 +163,9 @@ public:
 	virtual F32 getPixelAspectRatio() = 0;
 	virtual void setNativeAspectRatio(F32 aspect) = 0;
 	
+    // query VRAM usage
+    virtual U32 getAvailableVRAMMegabytes() = 0;
+
 	virtual void beforeDialog() {};	// prepare to put up an OS dialog (if special measures are required, such as in fullscreen mode)
 	virtual void afterDialog() {};	// undo whatever was done in beforeDialog()
 
diff --git a/indra/llwindow/llwindowheadless.h b/indra/llwindow/llwindowheadless.h
index 410da79623..0e1f603db7 100644
--- a/indra/llwindow/llwindowheadless.h
+++ b/indra/llwindow/llwindowheadless.h
@@ -96,6 +96,8 @@ public:
 	/*virtual*/ F32 getPixelAspectRatio() { return 1.0f; };
 	/*virtual*/ void setNativeAspectRatio(F32 ratio) {}
 
+    U32 getAvailableVRAMMegabytes() override { return 4096; }
+
 	/*virtual*/ void *getPlatformWindow() { return 0; };
 	/*virtual*/ void bringToFront() {};
 	
diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 9feccd7874..3afb78d1d2 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -47,6 +47,7 @@
 #include "llglslshader.h"
 #include "llthreadsafequeue.h"
 #include "stringize.h"
+#include "llframetimer.h"
 
 // System includes
 #include <commdlg.h>
@@ -61,6 +62,10 @@
 #include <sstream>
 #include <utility>                  // std::pair
 
+#include <d3d9.h>
+#include <dxgi1_4.h>
+
+
 // Require DirectInput version 8
 #define DIRECTINPUT_VERSION 0x0800
 
@@ -347,6 +352,20 @@ struct LLWindowWin32::LLWindowWin32Thread : public LL::ThreadPool
 
     void run() override;
 
+    // initialzie DXGI adapter (for querying available VRAM)
+    void initDX();
+    
+    // initialize D3D (if DXGI cannot be used)
+    void initD3D();
+
+    // call periodically to update available VRAM
+    void updateVRAMUsage();
+
+    U32 getAvailableVRAMMegabytes()
+    {
+        return mAvailableVRAM;
+    }
+
     /// called by main thread to post work to this window thread
     template <typename CALLABLE>
     void post(CALLABLE&& func)
@@ -395,6 +414,12 @@ struct LLWindowWin32::LLWindowWin32Thread : public LL::ThreadPool
     void gatherInput();
     HWND mWindowHandle = NULL;
     HDC mhDC = 0;
+
+    std::atomic<U32> mAvailableVRAM;
+
+    IDXGIAdapter3* mDXGIAdapter = nullptr;
+    LPDIRECT3D9 mD3D = nullptr;
+    LPDIRECT3DDEVICE9 mD3DDevice = nullptr;
 };
 
 
@@ -4507,6 +4532,10 @@ std::vector<std::string> LLWindowWin32::getDynamicFallbackFontList()
 	return std::vector<std::string>();
 }
 
+U32 LLWindowWin32::getAvailableVRAMMegabytes()
+{
+    return mWindowThread ? mWindowThread->getAvailableVRAMMegabytes() : 0;
+}
 
 #endif // LL_WINDOWS
 
@@ -4562,17 +4591,97 @@ private:
     std::string mPrev;
 };
 
+void LLWindowWin32::LLWindowWin32Thread::initDX()
+{
+    if (mDXGIAdapter == NULL)
+    {
+        IDXGIFactory4* pFactory = nullptr;
+
+        HRESULT res = CreateDXGIFactory1(__uuidof(IDXGIFactory4), (void**)&pFactory);
+
+        if (FAILED(res))
+        {
+            LL_WARNS() << "CreateDXGIFactory1 failed: 0x" << std::hex << res << LL_ENDL;
+        }
+        else
+        {
+            res = pFactory->EnumAdapters(0, reinterpret_cast<IDXGIAdapter**>(&mDXGIAdapter));
+            if (FAILED(res))
+            {
+                LL_WARNS() << "EnumAdapters failed: 0x" << std::hex << res << LL_ENDL;
+            }
+        }
+
+        pFactory->Release();
+    }
+}
+
+void LLWindowWin32::LLWindowWin32Thread::initD3D()
+{
+    if (mDXGIAdapter == NULL && mD3DDevice == NULL && mWindowHandle != 0)
+    {
+        mD3D = Direct3DCreate9(D3D_SDK_VERSION);
+        
+        D3DPRESENT_PARAMETERS d3dpp;
+
+        ZeroMemory(&d3dpp, sizeof(d3dpp));
+        d3dpp.Windowed = TRUE;
+        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+
+        mD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, mWindowHandle, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &mD3DDevice);
+    }
+}
+
+void LLWindowWin32::LLWindowWin32Thread::updateVRAMUsage()
+{
+    LL_PROFILE_ZONE_SCOPED;
+    if (mDXGIAdapter != nullptr)
+    {
+        DXGI_QUERY_VIDEO_MEMORY_INFO info;
+        mDXGIAdapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, &info);
+
+        // try to use no more than the available reserve minus 10%
+        U32 target = info.AvailableForReservation / 1024 / 1024;
+        target -= target / 10;
+
+        U32 used_vram = info.CurrentUsage / 1024 / 1024;
+
+        mAvailableVRAM = used_vram < target ? target - used_vram : 0;
+
+        /*LL_INFOS() << "\nLocal\nAFR: " << info.AvailableForReservation / 1024 / 1024
+            << "\nBudget: " << info.Budget / 1024 / 1024
+            << "\nCR: " << info.CurrentReservation / 1024 / 1024
+            << "\nCU: " << info.CurrentUsage / 1024 / 1024 << LL_ENDL;
+
+        mDXGIAdapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL, &info);
+        LL_INFOS() << "\nNon-Local\nAFR: " << info.AvailableForReservation / 1024 / 1024
+            << "\nBudget: " << info.Budget / 1024 / 1024
+            << "\nCR: " << info.CurrentReservation / 1024 / 1024
+            << "\nCU: " << info.CurrentUsage / 1024 / 1024 << LL_ENDL;*/
+    }
+    else if (mD3DDevice != NULL)
+    { // fallback to D3D9
+        mAvailableVRAM = mD3DDevice->GetAvailableTextureMem() / 1024 / 1024;
+    }
+
+}
+
 void LLWindowWin32::LLWindowWin32Thread::run()
 {
     sWindowThreadId = std::this_thread::get_id();
     LogChange logger("Window");
 
+    initDX();
+
     while (! getQueue().done())
     {
         LL_PROFILE_ZONE_SCOPED_CATEGORY_WIN32;
 
         if (mWindowHandle != 0)
         {
+            // lazily call initD3D inside this loop to catch when mWindowHandle has been set
+            initD3D();
+
             MSG msg;
             BOOL status;
             if (mhDC == 0)
@@ -4605,6 +4714,13 @@ void LLWindowWin32::LLWindowWin32Thread::run()
             getQueue().runPending();
         }
         
+        // update available vram once every 3 seconds
+        static LLFrameTimer vramTimer;
+        if (vramTimer.getElapsedTimeF32() > 3.f)
+        {
+            updateVRAMUsage();
+            vramTimer.reset();
+        }
 #if 0
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("w32t - Sleep");
@@ -4613,6 +4729,26 @@ void LLWindowWin32::LLWindowWin32Thread::run()
         }
 #endif
     }
+
+    //clean up DXGI/D3D resources
+    if (mDXGIAdapter)
+    {
+        mDXGIAdapter->Release();
+        mDXGIAdapter = nullptr;
+    }
+
+    if (mD3DDevice)
+    {
+        mD3DDevice->Release();
+        mD3DDevice = nullptr;
+    }
+
+    if (mD3D)
+    {
+        mD3D->Release();
+        mD3D = nullptr;
+    }
+
 }
 
 void LLWindowWin32::post(const std::function<void()>& func)
diff --git a/indra/llwindow/llwindowwin32.h b/indra/llwindow/llwindowwin32.h
index b391acc12d..bd53b3e92a 100644
--- a/indra/llwindow/llwindowwin32.h
+++ b/indra/llwindow/llwindowwin32.h
@@ -108,7 +108,9 @@ public:
 	/*virtual*/ F32 getPixelAspectRatio();
 	/*virtual*/ void setNativeAspectRatio(F32 ratio) { mOverrideAspectRatio = ratio; }
 
-	/*virtual*/	BOOL dialogColorPicker(F32 *r, F32 *g, F32 *b );
+    U32 getAvailableVRAMMegabytes() override;
+	
+    /*virtual*/	BOOL dialogColorPicker(F32 *r, F32 *g, F32 *b );
 
 	/*virtual*/ void *getPlatformWindow();
 	/*virtual*/ void bringToFront();
-- 
cgit v1.2.3


From 3604edc27eedff24dc1f17624a77c130b498e9f1 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 10 May 2022 12:20:19 -0400
Subject: SL-17219: LLWindowMacOSX needs getAvailableVRAMMegabytes().

This is just a placeholder, but without it the viewer won't even build on Mac.
---
 indra/llwindow/llwindow.h       | 6 +++---
 indra/llwindow/llwindowmacosx.h | 4 ++++
 2 files changed, 7 insertions(+), 3 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindow.h b/indra/llwindow/llwindow.h
index 507e6076d6..2c538a60c9 100644
--- a/indra/llwindow/llwindow.h
+++ b/indra/llwindow/llwindow.h
@@ -162,9 +162,9 @@ public:
 	virtual F32	getNativeAspectRatio() = 0;
 	virtual F32 getPixelAspectRatio() = 0;
 	virtual void setNativeAspectRatio(F32 aspect) = 0;
-	
-    // query VRAM usage
-    virtual U32 getAvailableVRAMMegabytes() = 0;
+
+	// query VRAM usage
+	virtual U32 getAvailableVRAMMegabytes() = 0;
 
 	virtual void beforeDialog() {};	// prepare to put up an OS dialog (if special measures are required, such as in fullscreen mode)
 	virtual void afterDialog() {};	// undo whatever was done in beforeDialog()
diff --git a/indra/llwindow/llwindowmacosx.h b/indra/llwindow/llwindowmacosx.h
index b0f339e1db..309d1377ea 100644
--- a/indra/llwindow/llwindowmacosx.h
+++ b/indra/llwindow/llwindowmacosx.h
@@ -100,6 +100,10 @@ public:
 	F32 getPixelAspectRatio() override;
 	void setNativeAspectRatio(F32 ratio) override { mOverrideAspectRatio = ratio; }
 
+	// query VRAM usage
+	// FIXME FIXME
+	virtual U32 getAvailableVRAMMegabytes() override { return 0; }
+
 	void beforeDialog() override;
 	void afterDialog() override;
 
-- 
cgit v1.2.3


From 4dddb17dfc0dc2c0bdd21263574707a91f2b00a9 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 10 May 2022 12:26:44 -0400
Subject: SL-17219: Mark LLWindowHeadless virtual overrides 'override'.

Also LLSplashScreenHeadless methods. Without this Mac builds fail.
---
 indra/llwindow/llwindowheadless.h | 133 ++++++++++++++++++++------------------
 1 file changed, 69 insertions(+), 64 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowheadless.h b/indra/llwindow/llwindowheadless.h
index 0e1f603db7..2f2c0de5bd 100644
--- a/indra/llwindow/llwindowheadless.h
+++ b/indra/llwindow/llwindowheadless.h
@@ -32,74 +32,79 @@
 class LLWindowHeadless : public LLWindow
 {
 public:
-	/*virtual*/ void show() {};
-	/*virtual*/ void hide() {};
-	/*virtual*/ void close() {};
-	/*virtual*/ BOOL getVisible() {return FALSE;};
-	/*virtual*/ BOOL getMinimized() {return FALSE;};
-	/*virtual*/ BOOL getMaximized() {return FALSE;};
-	/*virtual*/ BOOL maximize() {return FALSE;};
-	/*virtual*/ void minimize() {};
-	/*virtual*/ void restore() {};
-	/*virtual*/ BOOL getFullscreen() {return FALSE;};
-	/*virtual*/ BOOL getPosition(LLCoordScreen *position) {return FALSE;};
-	/*virtual*/ BOOL getSize(LLCoordScreen *size) {return FALSE;};
-	/*virtual*/ BOOL getSize(LLCoordWindow *size) {return FALSE;};
-	/*virtual*/ BOOL setPosition(LLCoordScreen position) {return FALSE;};
-	/*virtual*/ BOOL setSizeImpl(LLCoordScreen size) {return FALSE;};
-	/*virtual*/ BOOL setSizeImpl(LLCoordWindow size) {return FALSE;};
-	/*virtual*/ BOOL switchContext(BOOL fullscreen, const LLCoordScreen &size, BOOL enable_vsync, const LLCoordScreen * const posp = NULL) {return FALSE;};
-    void* createSharedContext()  { return nullptr; }
-    void makeContextCurrent(void*)  {}
-    void destroySharedContext(void*)  {}
-    /*virtual*/ void toggleVSync(bool enable_vsync) { }
-    /*virtual*/ BOOL setCursorPosition(LLCoordWindow position) {return FALSE;};
-    /*virtual*/ BOOL getCursorPosition(LLCoordWindow *position) {return FALSE;};
+	/*virtual*/ void show() override {}
+	/*virtual*/ void hide() override {}
+	/*virtual*/ void close() override {}
+	/*virtual*/ BOOL getVisible() override {return FALSE;}
+	/*virtual*/ BOOL getMinimized() override {return FALSE;}
+	/*virtual*/ BOOL getMaximized() override {return FALSE;}
+	/*virtual*/ BOOL maximize() override {return FALSE;}
+	/*virtual*/ void minimize() override {}
+	/*virtual*/ void restore() override {}
+	// TODO: LLWindow::getFullscreen() is (intentionally?) NOT virtual.
+	// Apparently the coder of LLWindowHeadless didn't realize that. Is it a
+	// mistake to shadow the base-class method with an LLWindowHeadless
+	// override when called on the subclass, yet call the base-class method
+	// when indirecting through a polymorphic pointer or reference?
+	BOOL getFullscreen() {return FALSE;}
+	/*virtual*/ BOOL getPosition(LLCoordScreen *position) override {return FALSE;}
+	/*virtual*/ BOOL getSize(LLCoordScreen *size) override {return FALSE;}
+	/*virtual*/ BOOL getSize(LLCoordWindow *size) override {return FALSE;}
+	/*virtual*/ BOOL setPosition(LLCoordScreen position) override {return FALSE;}
+	/*virtual*/ BOOL setSizeImpl(LLCoordScreen size) override {return FALSE;}
+	/*virtual*/ BOOL setSizeImpl(LLCoordWindow size) override {return FALSE;}
+	/*virtual*/ BOOL switchContext(BOOL fullscreen, const LLCoordScreen &size, BOOL enable_vsync, const LLCoordScreen * const posp = NULL) override {return FALSE;}
+    void* createSharedContext() override  { return nullptr; }
+    void makeContextCurrent(void*) override  {}
+    void destroySharedContext(void*) override  {}
+    /*virtual*/ void toggleVSync(bool enable_vsync) override { }
+    /*virtual*/ BOOL setCursorPosition(LLCoordWindow position) override {return FALSE;}
+    /*virtual*/ BOOL getCursorPosition(LLCoordWindow *position) override {return FALSE;}
 #if LL_WINDOWS
-    /*virtual*/ BOOL getCursorDelta(LLCoordCommon* delta) { return FALSE; }
+    /*virtual*/ BOOL getCursorDelta(LLCoordCommon* delta) override { return FALSE; }
 #endif
-	/*virtual*/ void showCursor() {};
-	/*virtual*/ void hideCursor() {};
-	/*virtual*/ void showCursorFromMouseMove() {};
-	/*virtual*/ void hideCursorUntilMouseMove() {};
-	/*virtual*/ BOOL isCursorHidden() {return FALSE;};
-	/*virtual*/ void updateCursor() {};
-	//virtual ECursorType getCursor() { return mCurrentCursor; };
-	/*virtual*/ void captureMouse() {};
-	/*virtual*/ void releaseMouse() {};
-	/*virtual*/ void setMouseClipping( BOOL b ) {};
-	/*virtual*/ BOOL isClipboardTextAvailable() {return FALSE; };
-	/*virtual*/ BOOL pasteTextFromClipboard(LLWString &dst) {return FALSE; };
-	/*virtual*/ BOOL copyTextToClipboard(const LLWString &src) {return FALSE; };
-	/*virtual*/ void flashIcon(F32 seconds) {};
-	/*virtual*/ F32 getGamma() {return 1.0f; };
-	/*virtual*/ BOOL setGamma(const F32 gamma) {return FALSE; }; // Set the gamma
-	/*virtual*/ void setFSAASamples(const U32 fsaa_samples) { }
-	/*virtual*/ U32 getFSAASamples() { return 0; }
-	/*virtual*/ BOOL restoreGamma() {return FALSE; };	// Restore original gamma table (before updating gamma)
-	//virtual ESwapMethod getSwapMethod() { return mSwapMethod; }
-	/*virtual*/ void gatherInput() {};
-	/*virtual*/ void delayInputProcessing() {};
-	/*virtual*/ void swapBuffers();
+	/*virtual*/ void showCursor() override {}
+	/*virtual*/ void hideCursor() override {}
+	/*virtual*/ void showCursorFromMouseMove() override {}
+	/*virtual*/ void hideCursorUntilMouseMove() override {}
+	/*virtual*/ BOOL isCursorHidden() override {return FALSE;}
+	/*virtual*/ void updateCursor() override {}
+	//virtual ECursorType getCursor() override { return mCurrentCursor; }
+	/*virtual*/ void captureMouse() override {}
+	/*virtual*/ void releaseMouse() override {}
+	/*virtual*/ void setMouseClipping( BOOL b ) override {}
+	/*virtual*/ BOOL isClipboardTextAvailable() override {return FALSE; }
+	/*virtual*/ BOOL pasteTextFromClipboard(LLWString &dst) override {return FALSE; }
+	/*virtual*/ BOOL copyTextToClipboard(const LLWString &src) override {return FALSE; }
+	/*virtual*/ void flashIcon(F32 seconds) override {}
+	/*virtual*/ F32 getGamma() override {return 1.0f; }
+	/*virtual*/ BOOL setGamma(const F32 gamma) override {return FALSE; } // Set the gamma
+	/*virtual*/ void setFSAASamples(const U32 fsaa_samples) override { }
+	/*virtual*/ U32 getFSAASamples() override { return 0; }
+	/*virtual*/ BOOL restoreGamma() override {return FALSE; }	// Restore original gamma table (before updating gamma)
+	//virtual ESwapMethod getSwapMethod() override { return mSwapMethod; }
+	/*virtual*/ void gatherInput() override {}
+	/*virtual*/ void delayInputProcessing() override {}
+	/*virtual*/ void swapBuffers() override;
 
 	
     // handy coordinate space conversion routines
-	/*virtual*/ BOOL convertCoords(LLCoordScreen from, LLCoordWindow *to) { return FALSE; };
-	/*virtual*/ BOOL convertCoords(LLCoordWindow from, LLCoordScreen *to) { return FALSE; };
-	/*virtual*/ BOOL convertCoords(LLCoordWindow from, LLCoordGL *to) { return FALSE; };
-	/*virtual*/ BOOL convertCoords(LLCoordGL from, LLCoordWindow *to) { return FALSE; };
-	/*virtual*/ BOOL convertCoords(LLCoordScreen from, LLCoordGL *to) { return FALSE; };
-	/*virtual*/ BOOL convertCoords(LLCoordGL from, LLCoordScreen *to) { return FALSE; };
+	/*virtual*/ BOOL convertCoords(LLCoordScreen from, LLCoordWindow *to) override { return FALSE; }
+	/*virtual*/ BOOL convertCoords(LLCoordWindow from, LLCoordScreen *to) override { return FALSE; }
+	/*virtual*/ BOOL convertCoords(LLCoordWindow from, LLCoordGL *to) override { return FALSE; }
+	/*virtual*/ BOOL convertCoords(LLCoordGL from, LLCoordWindow *to) override { return FALSE; }
+	/*virtual*/ BOOL convertCoords(LLCoordScreen from, LLCoordGL *to) override { return FALSE; }
+	/*virtual*/ BOOL convertCoords(LLCoordGL from, LLCoordScreen *to) override { return FALSE; }
 
-	/*virtual*/ LLWindowResolution* getSupportedResolutions(S32 &num_resolutions) { return NULL; };
-	/*virtual*/ F32	getNativeAspectRatio() { return 1.0f; };
-	/*virtual*/ F32 getPixelAspectRatio() { return 1.0f; };
-	/*virtual*/ void setNativeAspectRatio(F32 ratio) {}
+	/*virtual*/ LLWindowResolution* getSupportedResolutions(S32 &num_resolutions) override { return NULL; }
+	/*virtual*/ F32	getNativeAspectRatio() override { return 1.0f; }
+	/*virtual*/ F32 getPixelAspectRatio() override { return 1.0f; }
+	/*virtual*/ void setNativeAspectRatio(F32 ratio) override {}
 
     U32 getAvailableVRAMMegabytes() override { return 4096; }
 
-	/*virtual*/ void *getPlatformWindow() { return 0; };
-	/*virtual*/ void bringToFront() {};
+	/*virtual*/ void *getPlatformWindow() override { return 0; }
+	/*virtual*/ void bringToFront() override {}
 	
 	LLWindowHeadless(LLWindowCallbacks* callbacks,
 		const std::string& title, const std::string& name,
@@ -115,12 +120,12 @@ private:
 class LLSplashScreenHeadless : public LLSplashScreen
 {
 public:
-	LLSplashScreenHeadless() {};
-	virtual ~LLSplashScreenHeadless() {};
+	LLSplashScreenHeadless() {}
+	virtual ~LLSplashScreenHeadless() {}
 
-	/*virtual*/ void showImpl() {};
-	/*virtual*/ void updateImpl(const std::string& mesg) {};
-	/*virtual*/ void hideImpl() {};
+	/*virtual*/ void showImpl() override {}
+	/*virtual*/ void updateImpl(const std::string& mesg) override {}
+	/*virtual*/ void hideImpl() override {}
 
 };
 
-- 
cgit v1.2.3


From 6c6d9a10f830e264cf75603949b54a12256cab78 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 20 May 2022 13:31:18 -0500
Subject: SL-17287 Update Tracy to 0.8.1.  Clean up GPU instrumentation.

---
 indra/llwindow/llwindowwin32.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 1f3823509c..02b3c25129 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -1623,8 +1623,6 @@ const	S32   max_format  = (S32)num_formats - 1;
 		return FALSE;
 	}
 
-	LL_PROFILER_GPU_CONTEXT
-
 	if (!gGLManager.initGL())
 	{
 		OSMessageBox(mCallbacks->translateString("MBVideoDrvErr"), mCallbacks->translateString("MBError"), OSMB_OK);
@@ -1656,6 +1654,8 @@ const	S32   max_format  = (S32)num_formats - 1;
 		swapBuffers();
 	}
 
+    LL_PROFILER_GPU_CONTEXT;
+
 	return TRUE;
 }
 
@@ -1809,6 +1809,7 @@ void* LLWindowWin32::createSharedContext()
 void LLWindowWin32::makeContextCurrent(void* contextPtr)
 {
     wglMakeCurrent(mhDC, (HGLRC) contextPtr);
+    LL_PROFILER_GPU_CONTEXT;
 }
 
 void LLWindowWin32::destroySharedContext(void* contextPtr)
@@ -3577,7 +3578,7 @@ void LLWindowWin32::swapBuffers()
     glFlush(); //superstitious flush for maybe frame stall removal?
 	SwapBuffers(mhDC);
 
-    LL_PROFILER_GPU_COLLECT
+    LL_PROFILER_GPU_COLLECT;
 }
 
 
-- 
cgit v1.2.3


From 6eaf8521abae0deeb1162f9c61747183110176b0 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 20 May 2022 19:05:28 -0500
Subject: SL-17287 Instrument and optimize cubemap render.  Fix for cubemap
 snapshots doing a full resolution render instead of a 512x512 render.

---
 indra/llwindow/llwindowwin32.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 02b3c25129..67c50294e1 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -3575,7 +3575,10 @@ void LLWindowWin32::swapBuffers()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_WIN32;
     ASSERT_MAIN_THREAD();
-    glFlush(); //superstitious flush for maybe frame stall removal?
+    {
+        LL_PROFILE_GPU_ZONE("flush");
+        glFlush(); //superstitious flush for maybe frame stall removal?
+    }
 	SwapBuffers(mhDC);
 
     LL_PROFILER_GPU_COLLECT;
-- 
cgit v1.2.3


From da069765b1974e60df5ebf9e973c7fd00c52e329 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 8 Jun 2022 16:24:03 -0500
Subject: SL-17005 Tweak target VRAM usage and add some log spam to help zero
 in on good targets.

---
 indra/llwindow/llwindowwin32.cpp | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index da79660239..20443988ab 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -65,7 +65,6 @@
 #include <d3d9.h>
 #include <dxgi1_4.h>
 
-
 // Require DirectInput version 8
 #define DIRECTINPUT_VERSION 0x0800
 
@@ -4649,23 +4648,34 @@ void LLWindowWin32::LLWindowWin32Thread::updateVRAMUsage()
         mDXGIAdapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, &info);
 
         // try to use no more than the available reserve minus 10%
-        U32 target = info.AvailableForReservation / 1024 / 1024;
-        target -= target / 10;
+        U32 target = info.Budget / 1024 / 1024;
+
+        // EXPERIMENTAL
+        // Trying to zero in on a good target usage, code here should be tuned against observed behavior
+        // of various hardware.
+        if (target > 4096)  // if 4GB are installed, try to leave 2GB free 
+        {
+            target -= 2048;
+        }
+        else // if less than 4GB are installed, try not to use more than half of it
+        {
+            target /= 2;
+        }
 
         U32 used_vram = info.CurrentUsage / 1024 / 1024;
 
         mAvailableVRAM = used_vram < target ? target - used_vram : 0;
 
-        /*LL_INFOS() << "\nLocal\nAFR: " << info.AvailableForReservation / 1024 / 1024
+        LL_INFOS("Window") << "\nLocal\nAFR: " << info.AvailableForReservation / 1024 / 1024
             << "\nBudget: " << info.Budget / 1024 / 1024
             << "\nCR: " << info.CurrentReservation / 1024 / 1024
             << "\nCU: " << info.CurrentUsage / 1024 / 1024 << LL_ENDL;
 
         mDXGIAdapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL, &info);
-        LL_INFOS() << "\nNon-Local\nAFR: " << info.AvailableForReservation / 1024 / 1024
+        LL_INFOS("Window") << "\nNon-Local\nAFR: " << info.AvailableForReservation / 1024 / 1024
             << "\nBudget: " << info.Budget / 1024 / 1024
             << "\nCR: " << info.CurrentReservation / 1024 / 1024
-            << "\nCU: " << info.CurrentUsage / 1024 / 1024 << LL_ENDL;*/
+            << "\nCU: " << info.CurrentUsage / 1024 / 1024 << LL_ENDL;
     }
     else if (mD3DDevice != NULL)
     { // fallback to D3D9
-- 
cgit v1.2.3


From 758a602f20340c5efde626fcace5a11133cfb859 Mon Sep 17 00:00:00 2001
From: Howard Stearns <howard.stearns@gmail.com>
Date: Mon, 13 Jun 2022 13:47:34 -0700
Subject: SL-17485 - mac getVramSize should return all vram, not just
 texture-specific, and use to compute getAvailableVRAMMegabytes.

---
 indra/llwindow/llopenglview-objc.mm |  7 ++++++-
 indra/llwindow/llwindowmacosx.cpp   | 10 ++++++++++
 indra/llwindow/llwindowmacosx.h     |  3 +--
 3 files changed, 17 insertions(+), 3 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llopenglview-objc.mm b/indra/llwindow/llopenglview-objc.mm
index fd20f2ad15..8d064ec86c 100644
--- a/indra/llwindow/llopenglview-objc.mm
+++ b/indra/llwindow/llopenglview-objc.mm
@@ -141,7 +141,12 @@ attributedStringInfo getSegments(NSAttributedString *str)
     CGLError the_err = CGLQueryRendererInfo (CGDisplayIDToOpenGLDisplayMask(kCGDirectMainDisplay), &info, &num_renderers);
     if(0 == the_err)
     {
-        CGLDescribeRenderer (info, 0, kCGLRPTextureMemoryMegabytes, &vram_megabytes);
+        // The name, uses, and other platform definitions of gGLManager.mVRAM suggest that this is supposed to be total vram in MB,
+        // rather than, say, just the texture memory. The two exceptions are:
+        // 1. LLAppViewer::getViewerInfo() puts the value in a field labeled "TEXTURE_MEMORY"
+        // 2. For years, this present function used kCGLRPTextureMemoryMegabytes
+        // Now we use kCGLRPVideoMemoryMegabytes to bring it in line with everything else (except thatone label).
+        CGLDescribeRenderer (info, 0, kCGLRPVideoMemoryMegabytes, &vram_megabytes);
         CGLDestroyRendererInfo (info);
     }
     else
diff --git a/indra/llwindow/llwindowmacosx.cpp b/indra/llwindow/llwindowmacosx.cpp
index bc4f07941b..4bcb9b3aef 100644
--- a/indra/llwindow/llwindowmacosx.cpp
+++ b/indra/llwindow/llwindowmacosx.cpp
@@ -1222,6 +1222,16 @@ F32 LLWindowMacOSX::getPixelAspectRatio()
 	return 1.f;
 }
 
+U32 LLWindowMacOSX::getAvailableVRAMMegabytes() {
+    // MTL (and MoltenVK) has some additional gpu data, such as recommendedMaxWorkingSetSize and currentAllocatedSize.
+    // But these are not available for OpenGL and/or our current mimimum OS version.
+    // So we will estimate.
+    static const U32 mb = 1024*1024;
+    // We're asked for total available gpu memory, but we only have allocation info on texture usage. So estimate by doubling that.
+    static const U32 total_factor = 2; // estimated total/textures
+    return gGLManager.mVRAM - (LLImageGL::getTextureBytesAllocated() * total_factor/mb);
+}
+
 //static SInt32 oldWindowLevel;
 
 // MBW -- XXX -- There's got to be a better way than this.  Find it, please...
diff --git a/indra/llwindow/llwindowmacosx.h b/indra/llwindow/llwindowmacosx.h
index 309d1377ea..0f316f1ddf 100644
--- a/indra/llwindow/llwindowmacosx.h
+++ b/indra/llwindow/llwindowmacosx.h
@@ -101,8 +101,7 @@ public:
 	void setNativeAspectRatio(F32 ratio) override { mOverrideAspectRatio = ratio; }
 
 	// query VRAM usage
-	// FIXME FIXME
-	virtual U32 getAvailableVRAMMegabytes() override { return 0; }
+    /*virtual*/ U32 getAvailableVRAMMegabytes() override;
 
 	void beforeDialog() override;
 	void afterDialog() override;
-- 
cgit v1.2.3


From 47ee4aff475e5086bc532acf1b79a86adcb70d73 Mon Sep 17 00:00:00 2001
From: Cosmic Linden <cosmic@lindenlab.com>
Date: Tue, 9 Aug 2022 11:34:09 -0700
Subject: SL-17005: Fix crash in initDX when no factory

---
 indra/llwindow/llwindowwin32.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 20443988ab..6e5c1e504a 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -4619,7 +4619,10 @@ void LLWindowWin32::LLWindowWin32Thread::initDX()
             }
         }
 
-        pFactory->Release();
+        if (pFactory)
+        {
+            pFactory->Release();
+        }
     }
 }
 
-- 
cgit v1.2.3


From eac4540fc359b1390c8828f92c5ba75d44fd1308 Mon Sep 17 00:00:00 2001
From: Cosmic Linden <cosmic@lindenlab.com>
Date: Tue, 9 Aug 2022 11:48:51 -0700
Subject: SL-17005: (WIP) (DEBUG) Add logging for graphics adapters

---
 indra/llwindow/llwindowwin32.cpp | 67 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 6e5c1e504a..9e7ea15cd7 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -4598,10 +4598,77 @@ private:
     std::string mPrev;
 };
 
+// Print hardware debug info about available graphics adapters in ordinal order
+void debugEnumerateGraphicsAdapters()
+{
+    LL_INFOS("Window") << "Enumerating graphics adapters..." << LL_ENDL;
+
+    IDXGIFactory1* factory;
+    HRESULT res = CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&factory);
+    if (FAILED(res) || !factory)
+    {
+        LL_WARNS() << "CreateDXGIFactory1 failed: 0x" << std::hex << res << LL_ENDL;
+    }
+    else
+    {
+        UINT graphics_adapter_index = 0;
+        IDXGIAdapter3* dxgi_adapter;
+        while (true)
+        {
+            res = factory->EnumAdapters(graphics_adapter_index, reinterpret_cast<IDXGIAdapter**>(&dxgi_adapter));
+            if (FAILED(res))
+            {
+                if (graphics_adapter_index == 0)
+                {
+                    LL_WARNS() << "EnumAdapters failed: 0x" << std::hex << res << LL_ENDL;
+                }
+                else
+                {
+                    LL_INFOS("Window") << "Done enumerating graphics adapters" << LL_ENDL;
+                }
+            }
+            else
+            {
+                DXGI_ADAPTER_DESC desc;
+                dxgi_adapter->GetDesc(&desc);
+                std::wstring description_w((wchar_t*)desc.Description);
+                std::string description(description_w.begin(), description_w.end());
+                LL_INFOS("Window") << "Graphics adapter index: " << graphics_adapter_index << ", "
+                    << "Description: " << description << ", "
+                    << "DeviceId: " << desc.DeviceId << ", "
+                    << "SubSysId: " << desc.SubSysId << ", "
+                    << "AdapterLuid: " << desc.AdapterLuid.HighPart << "_" << desc.AdapterLuid.LowPart << ", "
+                    << "DedicatedVideoMemory: " << desc.DedicatedVideoMemory / 1024 / 1024 << ", "
+                    << "DedicatedSystemMemory: " << desc.DedicatedSystemMemory / 1024 / 1024 << ", "
+                    << "SharedSystemMemory: " << desc.SharedSystemMemory / 1024 / 1024 << LL_ENDL;
+            }
+
+            if (dxgi_adapter)
+            {
+                dxgi_adapter->Release();
+                dxgi_adapter = NULL;
+            }
+            else
+            {
+                break;
+            }
+
+            graphics_adapter_index++;
+        }
+    }
+
+    if (factory)
+    {
+        factory->Release();
+    }
+}
+
 void LLWindowWin32::LLWindowWin32Thread::initDX()
 {
     if (mDXGIAdapter == NULL)
     {
+        debugEnumerateGraphicsAdapters();
+
         IDXGIFactory4* pFactory = nullptr;
 
         HRESULT res = CreateDXGIFactory1(__uuidof(IDXGIFactory4), (void**)&pFactory);
-- 
cgit v1.2.3


From c790bf7f49328b479f1bcbfe0268ca0bec6e2376 Mon Sep 17 00:00:00 2001
From: Cosmic Linden <cosmic@lindenlab.com>
Date: Thu, 11 Aug 2022 11:10:25 -0700
Subject: SL-17005: (WIP) (Debug) Add logging and debug settings to assist in
 understanding Windows 8 failure modes. Most of this should be removed later

---
 indra/llwindow/llwindowwin32.cpp | 32 +++++++++++++++++++++++++++++---
 1 file changed, 29 insertions(+), 3 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 9e7ea15cd7..9e2e07102e 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -48,6 +48,8 @@
 #include "llthreadsafequeue.h"
 #include "stringize.h"
 #include "llframetimer.h"
+#include "commoncontrol.h" // TODO: Remove after testing
+#include "llsd.h" // TODO: Remove after testing
 
 // System includes
 #include <commdlg.h>
@@ -416,7 +418,9 @@ struct LLWindowWin32::LLWindowWin32Thread : public LL::ThreadPool
 
     std::atomic<U32> mAvailableVRAM;
 
+    bool mTryUseDXGIAdapter; // TODO: Remove after testing
     IDXGIAdapter3* mDXGIAdapter = nullptr;
+    bool mTryUseD3DDevice; // TODO: Remove after testing
     LPDIRECT3D9 mD3D = nullptr;
     LPDIRECT3DDEVICE9 mD3DDevice = nullptr;
 };
@@ -4549,6 +4553,14 @@ U32 LLWindowWin32::getAvailableVRAMMegabytes()
 inline LLWindowWin32::LLWindowWin32Thread::LLWindowWin32Thread()
     : ThreadPool("Window Thread", 1, MAX_QUEUE_SIZE)
 {
+    const LLSD skipDXGI{ LL::CommonControl::get("Global", "DisablePrimaryGraphicsMemoryAccounting") }; // TODO: Remove after testing
+    LL_WARNS() << "DisablePrimaryGraphicsMemoryAccounting: " << skipDXGI << ", as boolean: " << skipDXGI.asBoolean() << LL_ENDL;
+    mTryUseDXGIAdapter = !skipDXGI.asBoolean();
+    LL_WARNS() << "mTryUseDXGIAdapter: " << mTryUseDXGIAdapter << LL_ENDL;
+    const LLSD skipD3D{ LL::CommonControl::get("Global", "DisableSecondaryGraphicsMemoryAccounting") }; // TODO: Remove after testing
+    LL_WARNS() << "DisableSecondaryGraphicsMemoryAccounting: " << skipD3D << ", as boolean: " << skipD3D.asBoolean() << LL_ENDL;
+    mTryUseD3DDevice = !skipD3D.asBoolean();
+    LL_WARNS() << "mTryUseD3DDevice: " << mTryUseD3DDevice << LL_ENDL;
     ThreadPool::start();
 }
 
@@ -4665,7 +4677,7 @@ void debugEnumerateGraphicsAdapters()
 
 void LLWindowWin32::LLWindowWin32Thread::initDX()
 {
-    if (mDXGIAdapter == NULL)
+    if (mDXGIAdapter == NULL && mTryUseDXGIAdapter)
     {
         debugEnumerateGraphicsAdapters();
 
@@ -4684,6 +4696,10 @@ void LLWindowWin32::LLWindowWin32Thread::initDX()
             {
                 LL_WARNS() << "EnumAdapters failed: 0x" << std::hex << res << LL_ENDL;
             }
+            else
+            {
+                LL_INFOS() << "EnumAdapters success" << LL_ENDL;
+            }
         }
 
         if (pFactory)
@@ -4695,7 +4711,7 @@ void LLWindowWin32::LLWindowWin32Thread::initDX()
 
 void LLWindowWin32::LLWindowWin32Thread::initD3D()
 {
-    if (mDXGIAdapter == NULL && mD3DDevice == NULL && mWindowHandle != 0)
+    if (mDXGIAdapter == NULL && mD3DDevice == NULL && mTryUseD3DDevice && mWindowHandle != 0)
     {
         mD3D = Direct3DCreate9(D3D_SDK_VERSION);
         
@@ -4705,7 +4721,16 @@ void LLWindowWin32::LLWindowWin32Thread::initD3D()
         d3dpp.Windowed = TRUE;
         d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
 
-        mD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, mWindowHandle, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &mD3DDevice);
+        HRESULT res = mD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, mWindowHandle, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &mD3DDevice);
+        
+        if (FAILED(res))
+        {
+            LL_WARNS() << "(fallback) CreateDevice failed: 0x" << std::hex << res << LL_ENDL;
+        }
+        else
+        {
+            LL_INFOS() << "(fallback) CreateDevice success" << LL_ENDL;
+        }
     }
 }
 
@@ -4768,6 +4793,7 @@ void LLWindowWin32::LLWindowWin32Thread::run()
         if (mWindowHandle != 0)
         {
             // lazily call initD3D inside this loop to catch when mWindowHandle has been set
+            // *TODO: Shutdown if this fails when mWindowHandle exists
             initD3D();
 
             MSG msg;
-- 
cgit v1.2.3


From a02f6217008dc9a82995fba705d129796fe3014c Mon Sep 17 00:00:00 2001
From: Cosmic Linden <cosmic@lindenlab.com>
Date: Thu, 18 Aug 2022 16:29:52 -0700
Subject: SL-17005: Clean up debug code

---
 indra/llwindow/llwindowwin32.cpp | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 9e2e07102e..201330137f 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -48,8 +48,6 @@
 #include "llthreadsafequeue.h"
 #include "stringize.h"
 #include "llframetimer.h"
-#include "commoncontrol.h" // TODO: Remove after testing
-#include "llsd.h" // TODO: Remove after testing
 
 // System includes
 #include <commdlg.h>
@@ -418,9 +416,7 @@ struct LLWindowWin32::LLWindowWin32Thread : public LL::ThreadPool
 
     std::atomic<U32> mAvailableVRAM;
 
-    bool mTryUseDXGIAdapter; // TODO: Remove after testing
     IDXGIAdapter3* mDXGIAdapter = nullptr;
-    bool mTryUseD3DDevice; // TODO: Remove after testing
     LPDIRECT3D9 mD3D = nullptr;
     LPDIRECT3DDEVICE9 mD3DDevice = nullptr;
 };
@@ -4553,14 +4549,6 @@ U32 LLWindowWin32::getAvailableVRAMMegabytes()
 inline LLWindowWin32::LLWindowWin32Thread::LLWindowWin32Thread()
     : ThreadPool("Window Thread", 1, MAX_QUEUE_SIZE)
 {
-    const LLSD skipDXGI{ LL::CommonControl::get("Global", "DisablePrimaryGraphicsMemoryAccounting") }; // TODO: Remove after testing
-    LL_WARNS() << "DisablePrimaryGraphicsMemoryAccounting: " << skipDXGI << ", as boolean: " << skipDXGI.asBoolean() << LL_ENDL;
-    mTryUseDXGIAdapter = !skipDXGI.asBoolean();
-    LL_WARNS() << "mTryUseDXGIAdapter: " << mTryUseDXGIAdapter << LL_ENDL;
-    const LLSD skipD3D{ LL::CommonControl::get("Global", "DisableSecondaryGraphicsMemoryAccounting") }; // TODO: Remove after testing
-    LL_WARNS() << "DisableSecondaryGraphicsMemoryAccounting: " << skipD3D << ", as boolean: " << skipD3D.asBoolean() << LL_ENDL;
-    mTryUseD3DDevice = !skipD3D.asBoolean();
-    LL_WARNS() << "mTryUseD3DDevice: " << mTryUseD3DDevice << LL_ENDL;
     ThreadPool::start();
 }
 
@@ -4677,7 +4665,7 @@ void debugEnumerateGraphicsAdapters()
 
 void LLWindowWin32::LLWindowWin32Thread::initDX()
 {
-    if (mDXGIAdapter == NULL && mTryUseDXGIAdapter)
+    if (mDXGIAdapter == NULL)
     {
         debugEnumerateGraphicsAdapters();
 
@@ -4711,7 +4699,7 @@ void LLWindowWin32::LLWindowWin32Thread::initDX()
 
 void LLWindowWin32::LLWindowWin32Thread::initD3D()
 {
-    if (mDXGIAdapter == NULL && mD3DDevice == NULL && mTryUseD3DDevice && mWindowHandle != 0)
+    if (mDXGIAdapter == NULL && mD3DDevice == NULL && mWindowHandle != 0)
     {
         mD3D = Direct3DCreate9(D3D_SDK_VERSION);
         
-- 
cgit v1.2.3


From 9bee2a92d2eb1f48f8ca0061e546c5e9df38fe79 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 26 Aug 2022 10:51:42 -0500
Subject: SL-17997 Follow up from beta breakers results.

---
 indra/llwindow/llwindowwin32.cpp | 55 +++++++++++++++++++++++++++++-----------
 1 file changed, 40 insertions(+), 15 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 20443988ab..656439e71e 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -414,6 +414,7 @@ struct LLWindowWin32::LLWindowWin32Thread : public LL::ThreadPool
     HWND mWindowHandle = NULL;
     HDC mhDC = 0;
 
+    // best guess at available video memory in MB
     std::atomic<U32> mAvailableVRAM;
 
     IDXGIAdapter3* mDXGIAdapter = nullptr;
@@ -4644,44 +4645,68 @@ void LLWindowWin32::LLWindowWin32Thread::updateVRAMUsage()
     LL_PROFILE_ZONE_SCOPED;
     if (mDXGIAdapter != nullptr)
     {
+        // NOTE: what lies below is hand wavy math based on compatibility testing and observation against a variety of hardware
+        //  It doesn't make sense, but please don't refactor it to make sense. -- davep
+
         DXGI_QUERY_VIDEO_MEMORY_INFO info;
         mDXGIAdapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, &info);
 
-        // try to use no more than the available reserve minus 10%
-        U32 target = info.Budget / 1024 / 1024;
+#if 0 // debug 0 budget and 0 CU
+        info.Budget = 0;
+        info.CurrentUsage = 0;
+#endif
+
+        U32 budget_mb = info.Budget / 1024 / 1024;
+        U32 afr_mb = info.AvailableForReservation / 1024 / 1024;
+        // correct for systems that misreport budget
+        if (budget_mb == 0)
+        { 
+            // fall back to available for reservation clamped between 512MB and 2GB
+            budget_mb = llclamp(afr_mb, (U32) 512, (U32) 2048);
+        }
+
+        U32 cu_mb = info.CurrentUsage / 1024 / 1024;
+
+        // get an estimated usage based on texture bytes allocated
+        U32 eu_mb = LLImageGL::getTextureBytesAllocated() * 2 / 1024 / 1024;
 
-        // EXPERIMENTAL
-        // Trying to zero in on a good target usage, code here should be tuned against observed behavior
-        // of various hardware.
-        if (target > 4096)  // if 4GB are installed, try to leave 2GB free 
+        if (cu_mb == 0)
+        { // current usage is sometimes unreliable on Intel GPUs, fall back to estimated usage
+            cu_mb = llmax((U32)1, eu_mb);
+        }
+        F32 eu_error = (F32)((S32)eu_mb - (S32)cu_mb) / (F32)cu_mb;
+
+        U32 target_mb = info.Budget / 1024 / 1024;
+
+        if (target_mb > 4096)  // if 4GB are installed, try to leave 2GB free 
         {
-            target -= 2048;
+            target_mb -= 2048;
         }
         else // if less than 4GB are installed, try not to use more than half of it
         {
-            target /= 2;
+            target_mb /= 2;
         }
 
-        U32 used_vram = info.CurrentUsage / 1024 / 1024;
-
-        mAvailableVRAM = used_vram < target ? target - used_vram : 0;
+        mAvailableVRAM = cu_mb < target_mb ? target_mb - cu_mb : 0;
 
         LL_INFOS("Window") << "\nLocal\nAFR: " << info.AvailableForReservation / 1024 / 1024
             << "\nBudget: " << info.Budget / 1024 / 1024
             << "\nCR: " << info.CurrentReservation / 1024 / 1024
-            << "\nCU: " << info.CurrentUsage / 1024 / 1024 << LL_ENDL;
+            << "\nCU: " << info.CurrentUsage / 1024 / 1024
+            << "\nEU: " << eu_mb << llformat(" (%.2f)", eu_error)
+            << "\nTU: " << target_mb
+            << "\nAM: " << mAvailableVRAM << LL_ENDL;
 
-        mDXGIAdapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL, &info);
+        /*mDXGIAdapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL, &info);
         LL_INFOS("Window") << "\nNon-Local\nAFR: " << info.AvailableForReservation / 1024 / 1024
             << "\nBudget: " << info.Budget / 1024 / 1024
             << "\nCR: " << info.CurrentReservation / 1024 / 1024
-            << "\nCU: " << info.CurrentUsage / 1024 / 1024 << LL_ENDL;
+            << "\nCU: " << info.CurrentUsage / 1024 / 1024 << LL_ENDL;*/
     }
     else if (mD3DDevice != NULL)
     { // fallback to D3D9
         mAvailableVRAM = mD3DDevice->GetAvailableTextureMem() / 1024 / 1024;
     }
-
 }
 
 void LLWindowWin32::LLWindowWin32Thread::run()
-- 
cgit v1.2.3


From 509cfcad3167d6ea464c5bb19397daaf537a5594 Mon Sep 17 00:00:00 2001
From: Brad Kittenbrink <brad@lindenlab.com>
Date: Mon, 27 Jun 2022 10:16:27 -0700
Subject: experiments for turning on opengl core profile on mac for DRTVWR-559

---
 indra/llwindow/llopenglview-objc.mm | 1 +
 1 file changed, 1 insertion(+)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llopenglview-objc.mm b/indra/llwindow/llopenglview-objc.mm
index fd20f2ad15..f6d90f3479 100644
--- a/indra/llwindow/llopenglview-objc.mm
+++ b/indra/llwindow/llopenglview-objc.mm
@@ -256,6 +256,7 @@ attributedStringInfo getSegments(NSAttributedString *str)
 		NSOpenGLPFADepthSize, 24,
 		NSOpenGLPFAAlphaSize, 8,
 		NSOpenGLPFAColorSize, 24,
+		NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core,
 		0
     };
 	
-- 
cgit v1.2.3


From 2082443220fe344bb027c3acbf50fea0a99159c3 Mon Sep 17 00:00:00 2001
From: Howard Stearns <howard.stearns@gmail.com>
Date: Thu, 1 Sep 2022 10:58:27 -0700
Subject: SL-17967 - Git rid of ARB that is in core

---
 indra/llwindow/llopenglview-objc.mm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llopenglview-objc.mm b/indra/llwindow/llopenglview-objc.mm
index c4cdb45677..ceb80ed349 100644
--- a/indra/llwindow/llopenglview-objc.mm
+++ b/indra/llwindow/llopenglview-objc.mm
@@ -261,7 +261,7 @@ attributedStringInfo getSegments(NSAttributedString *str)
 		NSOpenGLPFADepthSize, 24,
 		NSOpenGLPFAAlphaSize, 8,
 		NSOpenGLPFAColorSize, 24,
-		NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core,
+		NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion4_1Core,
 		0
     };
 	
-- 
cgit v1.2.3


From 9448db5d4af7bba094e5bc51f85e5c2491d3f5a1 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 6 Oct 2022 18:40:01 -0500
Subject: SL-18190 Water shader WIP.  Better parallax correction for sphere
 probes.  Reduce probe memory footprint.  Remove framebuffer copies and move
 to deprecate stencil buffer usage.

---
 indra/llwindow/llwindowwin32.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 553507bc0c..aadf895271 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -1376,8 +1376,8 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen& size, BO
 		attrib_list[cur_attrib++] = WGL_DEPTH_BITS_ARB;
 		attrib_list[cur_attrib++] = 24;
 
-		attrib_list[cur_attrib++] = WGL_STENCIL_BITS_ARB;
-		attrib_list[cur_attrib++] = 8;
+		//attrib_list[cur_attrib++] = WGL_STENCIL_BITS_ARB; //stencil buffer is deprecated (performance penalty)
+		//attrib_list[cur_attrib++] = 8;
 
 		attrib_list[cur_attrib++] = WGL_DRAW_TO_WINDOW_ARB;
 		attrib_list[cur_attrib++] = GL_TRUE;
-- 
cgit v1.2.3


From ec5009d70eb0fd729126b2321b9d7d6118741573 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 13 Oct 2022 19:51:40 -0500
Subject: SL-18190 Potential fix for sapping CPU when "sleeping"

---
 indra/llwindow/llwindowwin32.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index aadf895271..6beb874e8c 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -66,6 +66,7 @@
 
 #include <d3d9.h>
 #include <dxgi1_4.h>
+#include <timeapi.h>
 
 // Require DirectInput version 8
 #define DIRECTINPUT_VERSION 0x0800
@@ -4827,6 +4828,14 @@ void LLWindowWin32::LLWindowWin32Thread::run()
 
     initDX();
 
+    //as good a place as any to up the MM timer resolution (see ms_sleep)
+    //attempt to set timer resolution to 1ms
+    TIMECAPS tc;
+    if (timeGetDevCaps(&tc, sizeof(TIMECAPS)) == TIMERR_NOERROR)
+    {
+        timeBeginPeriod(llclamp((U32) 1, tc.wPeriodMin, tc.wPeriodMax));
+    }
+
     while (! getQueue().done())
     {
         LL_PROFILE_ZONE_SCOPED_CATEGORY_WIN32;
-- 
cgit v1.2.3


From e2d1af5c4f7bdc04becb4a4fd56b7e9057bdfedc Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 17 Nov 2022 13:35:39 -0600
Subject: SL-18154 Profile guided optimizations -- remove some unneeded
 operations and make LLDrawPoolMaterials less branchy.

---
 indra/llwindow/llwindowwin32.cpp | 55 +++++++++++++++++++++++++++++++++++-----
 1 file changed, 48 insertions(+), 7 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 91d98fe0bf..950043dff2 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -438,6 +438,47 @@ LLWindowWin32::LLWindowWin32(LLWindowCallbacks* callbacks,
 	//MAINT-516 -- force a load of opengl32.dll just in case windows went sideways 
 	LoadLibrary(L"opengl32.dll");
 
+#if 0 // this is probably a bad idea, but keep it in your back pocket if you see what looks like
+        // process deprioritization during profiles
+    // force high thread priority
+    HANDLE hProcess = GetCurrentProcess();
+    HANDLE hThread = GetCurrentThread();
+
+    if (hProcess)
+    {
+        int priority = GetPriorityClass(hProcess);
+        if (priority < REALTIME_PRIORITY_CLASS)
+        {
+            if (SetPriorityClass(hProcess, REALTIME_PRIORITY_CLASS))
+            {
+                LL_INFOS() << "Set process priority to REALTIME_PRIORITY_CLASS" << LL_ENDL;
+            }
+            else
+            {
+                LL_INFOS() << "Failed to set process priority: " << std::hex << GetLastError() << LL_ENDL;
+            }
+        }
+    }
+
+    if (hThread)
+    {
+        int priority = GetThreadPriority(hThread);
+
+        if (priority < THREAD_PRIORITY_TIME_CRITICAL)
+        {
+            if (SetThreadPriority(hThread, THREAD_PRIORITY_TIME_CRITICAL))
+            {
+                LL_INFOS() << "Set thread priority to THREAD_PRIORITY_TIME_CRITICAL" << LL_ENDL;
+            }
+            else
+            {
+                LL_INFOS() << "Failed to set thread priority: " << std::hex << GetLastError() << LL_ENDL;
+            }
+        }
+    }
+#endif
+
+
 	mFSAASamples = fsaa_samples;
 	mIconResource = gIconResource;
 	mOverrideAspectRatio = 0.f;
@@ -3554,7 +3595,7 @@ BOOL LLWindowWin32::setDisplayResolution(S32 width, S32 height, S32 bits, S32 re
 	// Don't change anything if we don't have to
 	if (EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dev_mode))
 	{
-		if (dev_mode.dmPelsWidth        == width &&
+		if (dev_mode.dmPelsWidth        == width && 
 			dev_mode.dmPelsHeight       == height &&
 			dev_mode.dmBitsPerPel       == bits &&
 			dev_mode.dmDisplayFrequency == refresh )
@@ -3620,15 +3661,15 @@ BOOL LLWindowWin32::resetDisplayResolution()
 
 void LLWindowWin32::swapBuffers()
 {
-    LL_PROFILE_ZONE_SCOPED_CATEGORY_WIN32;
-    ASSERT_MAIN_THREAD();
     {
-        LL_PROFILE_GPU_ZONE("flush");
-        glFlush(); //superstitious flush for maybe frame stall removal?
+        LL_PROFILE_ZONE_SCOPED_CATEGORY_WIN32;
+        SwapBuffers(mhDC);
     }
-	SwapBuffers(mhDC);
 
-    LL_PROFILER_GPU_COLLECT;
+    {
+        LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("GPU Collect");
+        LL_PROFILER_GPU_COLLECT;
+    }
 }
 
 
-- 
cgit v1.2.3


From b5db671f7c28eb2a9f9974df1c34cf8c025fb8cc Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Tue, 29 Nov 2022 09:15:02 -0600
Subject: SL-18682 WIP -- Add debug settings that aid in emulating low end
 hardware.

---
 indra/llwindow/llwindow.cpp      |  7 +++++--
 indra/llwindow/llwindow.h        |  5 ++++-
 indra/llwindow/llwindowwin32.cpp | 45 +++++++++++++++++++++++++++++++++++-----
 indra/llwindow/llwindowwin32.h   |  4 +++-
 4 files changed, 52 insertions(+), 9 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindow.cpp b/indra/llwindow/llwindow.cpp
index f4678a70c5..66be3efffc 100644
--- a/indra/llwindow/llwindow.cpp
+++ b/indra/llwindow/llwindow.cpp
@@ -406,7 +406,10 @@ LLWindow* LLWindowManager::createWindow(
 	BOOL enable_vsync,
 	BOOL use_gl,
 	BOOL ignore_pixel_depth,
-	U32 fsaa_samples)
+	U32 fsaa_samples,
+    U32 max_cores,
+    U32 max_vram,
+    F32 max_gl_version)
 {
 	LLWindow* new_window;
 
@@ -423,7 +426,7 @@ LLWindow* LLWindowManager::createWindow(
 #elif LL_WINDOWS
 		new_window = new LLWindowWin32(callbacks,
 			title, name, x, y, width, height, flags, 
-			fullscreen, clearBg, enable_vsync, use_gl, ignore_pixel_depth, fsaa_samples);
+			fullscreen, clearBg, enable_vsync, use_gl, ignore_pixel_depth, fsaa_samples, max_cores, max_vram, max_gl_version);
 #elif LL_DARWIN
 		new_window = new LLWindowMacOSX(callbacks,
 			title, name, x, y, width, height, flags, 
diff --git a/indra/llwindow/llwindow.h b/indra/llwindow/llwindow.h
index 2c538a60c9..862897a48c 100644
--- a/indra/llwindow/llwindow.h
+++ b/indra/llwindow/llwindow.h
@@ -302,7 +302,10 @@ public:
 		BOOL enable_vsync = FALSE,
 		BOOL use_gl = TRUE,
 		BOOL ignore_pixel_depth = FALSE,
-		U32 fsaa_samples = 0);
+		U32 fsaa_samples = 0,
+        U32 max_cores = 0,
+        U32 max_vram = 0,
+        F32 max_gl_version = 4.6f);
 	static BOOL destroyWindow(LLWindow* window);
 	static BOOL isWindowValid(LLWindow *window);
 };
diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 950043dff2..c0d3424141 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -418,6 +418,8 @@ struct LLWindowWin32::LLWindowWin32Thread : public LL::ThreadPool
     // best guess at available video memory in MB
     std::atomic<U32> mAvailableVRAM;
 
+    U32 mMaxVRAM = 0; // maximum amount of vram to allow in the "budget", or 0 for no maximum (see updateVRAMUsage)
+
     IDXGIAdapter3* mDXGIAdapter = nullptr;
     LPDIRECT3D9 mD3D = nullptr;
     LPDIRECT3DDEVICE9 mD3DDevice = nullptr;
@@ -430,13 +432,36 @@ LLWindowWin32::LLWindowWin32(LLWindowCallbacks* callbacks,
 							 BOOL fullscreen, BOOL clearBg,
 							 BOOL enable_vsync, BOOL use_gl,
 							 BOOL ignore_pixel_depth,
-							 U32 fsaa_samples)
-	: LLWindow(callbacks, fullscreen, flags)
+							 U32 fsaa_samples,
+                             U32 max_cores,
+                             U32 max_vram,
+                             F32 max_gl_version)
+	: 
+    LLWindow(callbacks, fullscreen, flags), 
+    mMaxGLVersion(max_gl_version), 
+    mMaxCores(max_cores)
 {
     sMainThreadId = LLThread::currentID();
     mWindowThread = new LLWindowWin32Thread();
+    mWindowThread->mMaxVRAM = max_vram;
+
 	//MAINT-516 -- force a load of opengl32.dll just in case windows went sideways 
 	LoadLibrary(L"opengl32.dll");
+    
+    
+    if (mMaxCores != 0)
+    {
+        HANDLE hProcess = GetCurrentProcess();
+        mMaxCores = llmin(mMaxCores, (U32) 64);
+        DWORD_PTR mask = 0;
+
+        for (int i = 0; i < mMaxCores; ++i)
+        {
+            mask |= ((DWORD_PTR) 1) << i;
+        }
+
+        SetProcessAffinityMask(hProcess, mask);
+    }
 
 #if 0 // this is probably a bad idea, but keep it in your back pocket if you see what looks like
         // process deprioritization during profiles
@@ -1833,10 +1858,15 @@ void LLWindowWin32::recreateWindow(RECT window_rect, DWORD dw_ex_style, DWORD dw
 
 void* LLWindowWin32::createSharedContext()
 {
+    mMaxGLVersion = llclamp(mMaxGLVersion, 3.2f, 4.6f);
+
+    S32 version_major = llfloor(mMaxGLVersion);
+    S32 version_minor = llround((mMaxGLVersion-version_major)*10);
+
     S32 attribs[] =
     {
-        WGL_CONTEXT_MAJOR_VERSION_ARB, 4,
-        WGL_CONTEXT_MINOR_VERSION_ARB, 6,
+        WGL_CONTEXT_MAJOR_VERSION_ARB, version_major,
+        WGL_CONTEXT_MINOR_VERSION_ARB, version_minor,
         WGL_CONTEXT_PROFILE_MASK_ARB,  LLRender::sGLCoreProfile ? WGL_CONTEXT_CORE_PROFILE_BIT_ARB : WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
         WGL_CONTEXT_FLAGS_ARB, gDebugGL ? WGL_CONTEXT_DEBUG_BIT_ARB : 0,
         0
@@ -4815,6 +4845,11 @@ void LLWindowWin32::LLWindowWin32Thread::updateVRAMUsage()
             budget_mb = llclamp(afr_mb, (U32) 512, (U32) 2048);
         }
 
+        if ( mMaxVRAM != 0)
+        {
+            budget_mb = llmin(budget_mb, mMaxVRAM);
+        }
+
         U32 cu_mb = info.CurrentUsage / 1024 / 1024;
 
         // get an estimated usage based on texture bytes allocated
@@ -4826,7 +4861,7 @@ void LLWindowWin32::LLWindowWin32Thread::updateVRAMUsage()
         }
         F32 eu_error = (F32)((S32)eu_mb - (S32)cu_mb) / (F32)cu_mb;
 
-        U32 target_mb = info.Budget / 1024 / 1024;
+        U32 target_mb = budget_mb;
 
         if (target_mb > 4096)  // if 4GB are installed, try to leave 2GB free 
         {
diff --git a/indra/llwindow/llwindowwin32.h b/indra/llwindow/llwindowwin32.h
index bd53b3e92a..ff287a140e 100644
--- a/indra/llwindow/llwindowwin32.h
+++ b/indra/llwindow/llwindowwin32.h
@@ -139,7 +139,7 @@ protected:
 	LLWindowWin32(LLWindowCallbacks* callbacks,
 		const std::string& title, const std::string& name, int x, int y, int width, int height, U32 flags, 
 		BOOL fullscreen, BOOL clearBg, BOOL enable_vsync, BOOL use_gl,
-		BOOL ignore_pixel_depth, U32 fsaa_samples);
+		BOOL ignore_pixel_depth, U32 fsaa_samples, U32 max_cores, U32 max_vram, F32 max_gl_version);
 	~LLWindowWin32();
 
 	void	initCursors();
@@ -210,6 +210,8 @@ protected:
 
 	F32			mCurrentGamma;
 	U32			mFSAASamples;
+    U32         mMaxCores; // for debugging only -- maximum number of CPU cores to use, or 0 for no limit
+    F32         mMaxGLVersion; // maximum OpenGL version to attempt to use (clamps to 3.2 - 4.6)
 	WORD		mPrevGammaRamp[3][256];
 	WORD		mCurrentGammaRamp[3][256];
 	BOOL		mCustomGammaSet;
-- 
cgit v1.2.3


From 87bb72a47a1fc64b98e498120e332de76e6a9211 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 30 Nov 2022 13:25:00 -0600
Subject: SL-18154 WIP -- CPU sampling (AMD uProf) profile guided optimizations
 to reduce CPU usage of background threads.

---
 indra/llwindow/llwindowwin32.cpp | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index c0d3424141..be5af8240f 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -467,7 +467,6 @@ LLWindowWin32::LLWindowWin32(LLWindowCallbacks* callbacks,
         // process deprioritization during profiles
     // force high thread priority
     HANDLE hProcess = GetCurrentProcess();
-    HANDLE hThread = GetCurrentThread();
 
     if (hProcess)
     {
@@ -484,6 +483,20 @@ LLWindowWin32::LLWindowWin32(LLWindowCallbacks* callbacks,
             }
         }
     }
+#endif
+
+#if 0  // this is also probably a bad idea, but keep it in your back pocket for getting main thread off of background thread cores (see also LLThread::threadRun)
+    HANDLE hThread = GetCurrentThread();
+
+    SYSTEM_INFO sysInfo;
+
+    GetSystemInfo(&sysInfo);
+    U32 core_count = sysInfo.dwNumberOfProcessors;
+
+    if (max_cores != 0)
+    {
+        core_count = llmin(core_count, max_cores);
+    }
 
     if (hThread)
     {
@@ -499,6 +512,9 @@ LLWindowWin32::LLWindowWin32(LLWindowCallbacks* callbacks,
             {
                 LL_INFOS() << "Failed to set thread priority: " << std::hex << GetLastError() << LL_ENDL;
             }
+
+            // tell main thread to prefer core 0
+            SetThreadIdealProcessor(hThread, 0);
         }
     }
 #endif
-- 
cgit v1.2.3


From 2ab424493f09ffcc58ad32922fb6ff52790de2ce Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Mon, 12 Dec 2022 13:49:28 -0600
Subject: DRTVWR-559 Fix for windows build.

---
 indra/llwindow/llwindowwin32.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index be5af8240f..778acbd16f 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -4661,9 +4661,9 @@ U32 LLWindowWin32::getAvailableVRAMMegabytes()
 #endif // LL_WINDOWS
 
 inline LLWindowWin32::LLWindowWin32Thread::LLWindowWin32Thread()
-    : ThreadPool("Window Thread", 1, MAX_QUEUE_SIZE)
+    : LL::ThreadPool("Window Thread", 1, MAX_QUEUE_SIZE)
 {
-    ThreadPool::start();
+    LL::ThreadPool::start();
 }
 
 /**
-- 
cgit v1.2.3


From 89f21f276fe369e6c28abb6ff44200e2cb8098c8 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 16 Dec 2022 14:58:02 -0600
Subject: SL-18719 GL 3.0/3.1 compatibility pass.

---
 indra/llwindow/llwindowwin32.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index a74c4172eb..7787e2eb26 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -1874,7 +1874,7 @@ void LLWindowWin32::recreateWindow(RECT window_rect, DWORD dw_ex_style, DWORD dw
 
 void* LLWindowWin32::createSharedContext()
 {
-    mMaxGLVersion = llclamp(mMaxGLVersion, 3.2f, 4.6f);
+    mMaxGLVersion = llclamp(mMaxGLVersion, 3.f, 4.6f);
 
     S32 version_major = llfloor(mMaxGLVersion);
     S32 version_minor = llround((mMaxGLVersion-version_major)*10);
-- 
cgit v1.2.3


From 7bd9d21e19b923096ba2b5ea3cbc8be3e13d7aa0 Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Thu, 19 Jan 2023 09:13:45 -0600
Subject: Optimizations, decruft, and intel compatibility pass (#53)

SL-18869, SL-18772  Overhaul VBO management, restore occlusion culling, intel compatibility pass, etc
---
 indra/llwindow/llwindowwin32.cpp | 36 ++++++++++++------------------------
 1 file changed, 12 insertions(+), 24 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 7787e2eb26..a195964bb1 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -1051,16 +1051,19 @@ BOOL LLWindowWin32::maximize()
 	BOOL success = FALSE;
 	if (!mWindowHandle) return success;
 
-	WINDOWPLACEMENT placement;
-	placement.length = sizeof(WINDOWPLACEMENT);
-
-	success = GetWindowPlacement(mWindowHandle, &placement);
-	if (!success) return success;
+    mWindowThread->post([=]
+        {
+            WINDOWPLACEMENT placement;
+            placement.length = sizeof(WINDOWPLACEMENT);
 
-	placement.showCmd = SW_MAXIMIZE;
+            if (GetWindowPlacement(mWindowHandle, &placement))
+            {
+                placement.showCmd = SW_MAXIMIZE;
+                SetWindowPlacement(mWindowHandle, &placement);
+            }
+        });
 
-	success = SetWindowPlacement(mWindowHandle, &placement);
-	return success;
+    return TRUE;
 }
 
 BOOL LLWindowWin32::getFullscreen()
@@ -1408,14 +1411,6 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen& size, BO
 		return FALSE;
 	}
 
-	if (pfd.cAlphaBits < 8)
-	{
-		OSMessageBox(mCallbacks->translateString("MBAlpha"),
-			mCallbacks->translateString("MBError"), OSMB_OK);
-        close();
-		return FALSE;
-	}
-
 	if (!SetPixelFormat(mhDC, pixel_format, &pfd))
 	{
 		OSMessageBox(mCallbacks->translateString("MBPixelFmtSetErr"),
@@ -1474,7 +1469,7 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen& size, BO
 		attrib_list[cur_attrib++] = 24;
 
 		attrib_list[cur_attrib++] = WGL_ALPHA_BITS_ARB;
-		attrib_list[cur_attrib++] = 8;
+		attrib_list[cur_attrib++] = 0;
 
 		U32 end_attrib = 0;
 		if (mFSAASamples > 0)
@@ -1705,13 +1700,6 @@ const	S32   max_format  = (S32)num_formats - 1;
 		return FALSE;
 	}
 
-	if (pfd.cAlphaBits < 8)
-	{
-		OSMessageBox(mCallbacks->translateString("MBAlpha"), mCallbacks->translateString("MBError"), OSMB_OK);
-		close();
-		return FALSE;
-	}
-
 	mhRC = 0;
 	if (wglCreateContextAttribsARB)
 	{ //attempt to create a specific versioned context
-- 
cgit v1.2.3


From 95de63eaa3bab44dc435d1448d0732d6ffe13544 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Wed, 8 Feb 2023 11:10:15 -0600
Subject: DRTVWR-559 Remove some 32-bit color paranoia checks (potential fix
 for running under wine)

---
 indra/llwindow/llwindowwin32.cpp | 16 ----------------
 1 file changed, 16 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index a195964bb1..10cf7513b5 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -1403,14 +1403,6 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen& size, BO
 	LL_INFOS("Window") << "pfd.dwDamageMask:     " << pfd.dwDamageMask << LL_ENDL ;
 	LL_INFOS("Window") << "--- end pixel format dump ---" << LL_ENDL ;
 
-	if (pfd.cColorBits < 32)
-	{
-		OSMessageBox(mCallbacks->translateString("MBTrueColorWindow"),
-			mCallbacks->translateString("MBError"), OSMB_OK);
-        close();
-		return FALSE;
-	}
-
 	if (!SetPixelFormat(mhDC, pixel_format, &pfd))
 	{
 		OSMessageBox(mCallbacks->translateString("MBPixelFmtSetErr"),
@@ -1692,14 +1684,6 @@ const	S32   max_format  = (S32)num_formats - 1;
 		<< " Depth Bits " << S32(pfd.cDepthBits) 
 		<< LL_ENDL;
 
-	// make sure we have 32 bits per pixel
-	if (pfd.cColorBits < 32 || GetDeviceCaps(mhDC, BITSPIXEL) < 32)
-	{
-		OSMessageBox(mCallbacks->translateString("MBTrueColorWindow"), mCallbacks->translateString("MBError"), OSMB_OK);
-		close();
-		return FALSE;
-	}
-
 	mhRC = 0;
 	if (wglCreateContextAttribsARB)
 	{ //attempt to create a specific versioned context
-- 
cgit v1.2.3


From 25ede8638209fac8dde5b71bece4bc1dfa30ea16 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 10 Mar 2023 10:52:35 -0600
Subject: SL-19172 Texture streaming tune up.  Incidental decruft.

---
 indra/llwindow/llwindowwin32.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 10cf7513b5..666adcf672 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -4857,13 +4857,14 @@ void LLWindowWin32::LLWindowWin32Thread::updateVRAMUsage()
 
         DXGI_QUERY_VIDEO_MEMORY_INFO info;
         mDXGIAdapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, &info);
-
 #if 0 // debug 0 budget and 0 CU
         info.Budget = 0;
         info.CurrentUsage = 0;
 #endif
 
         U32 budget_mb = info.Budget / 1024 / 1024;
+        gGLManager.mVRAM = llmax(gGLManager.mVRAM, (S32) budget_mb);
+
         U32 afr_mb = info.AvailableForReservation / 1024 / 1024;
         // correct for systems that misreport budget
         if (budget_mb == 0)
-- 
cgit v1.2.3


From e09475713b7abe6fcb916f4a770081a1696b57ab Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Tue, 2 May 2023 18:47:21 -0500
Subject: DRTVWR-559 Optimization pass, make it so profileAvatar can read back
 GPU timer without a frame stall.

---
 indra/llwindow/llwindowwin32.cpp | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 651c04f32c..de2188efb2 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -4898,8 +4898,6 @@ void LLWindowWin32::LLWindowWin32Thread::updateVRAMUsage()
         { // current usage is sometimes unreliable on Intel GPUs, fall back to estimated usage
             cu_mb = llmax((U32)1, eu_mb);
         }
-        F32 eu_error = (F32)((S32)eu_mb - (S32)cu_mb) / (F32)cu_mb;
-
         U32 target_mb = budget_mb;
 
         if (target_mb > 4096)  // if 4GB are installed, try to leave 2GB free 
@@ -4913,6 +4911,9 @@ void LLWindowWin32::LLWindowWin32Thread::updateVRAMUsage()
 
         mAvailableVRAM = cu_mb < target_mb ? target_mb - cu_mb : 0;
 
+#if 0
+        
+        F32 eu_error = (F32)((S32)eu_mb - (S32)cu_mb) / (F32)cu_mb;
         LL_INFOS("Window") << "\nLocal\nAFR: " << info.AvailableForReservation / 1024 / 1024
             << "\nBudget: " << info.Budget / 1024 / 1024
             << "\nCR: " << info.CurrentReservation / 1024 / 1024
@@ -4920,12 +4921,7 @@ void LLWindowWin32::LLWindowWin32Thread::updateVRAMUsage()
             << "\nEU: " << eu_mb << llformat(" (%.2f)", eu_error)
             << "\nTU: " << target_mb
             << "\nAM: " << mAvailableVRAM << LL_ENDL;
-
-        /*mDXGIAdapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL, &info);
-        LL_INFOS("Window") << "\nNon-Local\nAFR: " << info.AvailableForReservation / 1024 / 1024
-            << "\nBudget: " << info.Budget / 1024 / 1024
-            << "\nCR: " << info.CurrentReservation / 1024 / 1024
-            << "\nCU: " << info.CurrentUsage / 1024 / 1024 << LL_ENDL;*/
+#endif
     }
     else if (mD3DDevice != NULL)
     { // fallback to D3D9
-- 
cgit v1.2.3


From 2a10bd406c9155d30a82657ce2ee532b3a677d83 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 3 May 2023 09:55:31 -0400
Subject: DRTVWR-559: Replace debugLoggingEnabled() function with LL_DEBUGS().

The trouble with debugLoggingEnabled() is that it locked mutexes and searched
maps every time that call was reached. LL_DEBUGS() has the same functionality
(albeit with idiosyncratic syntax) but performs expensive lookups only once
per session, caching the result in a local static variable.
---
 indra/llwindow/llwindowwin32.cpp | 124 ++++++++++++---------------------------
 1 file changed, 39 insertions(+), 85 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 651c04f32c..e50da8e836 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -2308,8 +2308,6 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
 
     LLWindowWin32* window_imp = (LLWindowWin32*)GetWindowLongPtr(h_wnd, GWLP_USERDATA);
 
-    bool debug_window_proc = false; // gDebugWindowProc || debugLoggingEnabled("Window");
-
     if (NULL != window_imp)
     {
         // Juggle to make sure we can get negative positions for when
@@ -2336,11 +2334,8 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_DEVICECHANGE:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_DEVICECHANGE");
-            if (debug_window_proc)
-            {
-                LL_INFOS("Window") << "  WM_DEVICECHANGE: wParam=" << w_param
-                    << "; lParam=" << l_param << LL_ENDL;
-            }
+            LL_INFOS("Window") << "  WM_DEVICECHANGE: wParam=" << w_param
+                << "; lParam=" << l_param << LL_ENDL;
             if (w_param == DBT_DEVNODES_CHANGED || w_param == DBT_DEVICEARRIVAL)
             {
                 WINDOW_IMP_POST(window_imp->mCallbacks->handleDeviceChange(window_imp));
@@ -2404,14 +2399,11 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                     BOOL activating = (BOOL)w_param;
                     BOOL minimized = window_imp->getMinimized();
 
-                    if (debug_window_proc)
-                    {
-                        LL_INFOS("Window") << "WINDOWPROC ActivateApp "
-                            << " activating " << S32(activating)
-                            << " minimized " << S32(minimized)
-                            << " fullscreen " << S32(window_imp->mFullscreen)
-                            << LL_ENDL;
-                    }
+                    LL_INFOS("Window") << "WINDOWPROC ActivateApp "
+                        << " activating " << S32(activating)
+                        << " minimized " << S32(minimized)
+                        << " fullscreen " << S32(window_imp->mFullscreen)
+                        << LL_ENDL;
 
                     if (window_imp->mFullscreen)
                     {
@@ -2456,13 +2448,10 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                     // JC - I'm not sure why, but if we don't report that we handled the 
                     // WM_ACTIVATE message, the WM_ACTIVATEAPP messages don't work 
                     // properly when we run fullscreen.
-                    if (debug_window_proc)
-                    {
-                        LL_INFOS("Window") << "WINDOWPROC Activate "
-                            << " activating " << S32(activating)
-                            << " minimized " << S32(minimized)
-                            << LL_ENDL;
-                    }
+                    LL_INFOS("Window") << "WINDOWPROC Activate "
+                        << " activating " << S32(activating)
+                        << " minimized " << S32(minimized)
+                        << LL_ENDL;
                 });
             
             break;
@@ -2541,12 +2530,9 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                     window_imp->mRawLParam = l_param;
 
                     {
-                        if (debug_window_proc)
-                        {
-                            LL_INFOS("Window") << "Debug WindowProc WM_KEYDOWN "
-                                << " key " << S32(w_param)
-                                << LL_ENDL;
-                        }
+                        LL_INFOS("Window") << "Debug WindowProc WM_KEYDOWN "
+                            << " key " << S32(w_param)
+                            << LL_ENDL;
                         
                         gKeyboard->handleKeyDown(w_param, mask);
                     }
@@ -2571,12 +2557,9 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                 {
                     LL_RECORD_BLOCK_TIME(FTM_KEYHANDLER);
 
-                    if (debug_window_proc)
-                    {
-                        LL_INFOS("Window") << "Debug WindowProc WM_KEYUP "
-                            << " key " << S32(w_param)
-                            << LL_ENDL;
-                    }
+                    LL_INFOS("Window") << "Debug WindowProc WM_KEYUP "
+                        << " key " << S32(w_param)
+                        << LL_ENDL;
                     gKeyboard->handleKeyUp(w_param, mask);
                 }
             });
@@ -2586,10 +2569,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_IME_SETCONTEXT:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_IME_SETCONTEXT");
-            if (debug_window_proc)
-            {
-                LL_INFOS("Window") << "WM_IME_SETCONTEXT" << LL_ENDL;
-            }
+            LL_INFOS("Window") << "WM_IME_SETCONTEXT" << LL_ENDL;
             if (LLWinImm::isAvailable() && window_imp->mPreeditor)
             {
                 l_param &= ~ISC_SHOWUICOMPOSITIONWINDOW;
@@ -2600,10 +2580,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_IME_STARTCOMPOSITION:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_IME_STARTCOMPOSITION");
-            if (debug_window_proc)
-            {
-                LL_INFOS() << "WM_IME_STARTCOMPOSITION" << LL_ENDL;
-            }
+            LL_INFOS("Window") << "WM_IME_STARTCOMPOSITION" << LL_ENDL;
             if (LLWinImm::isAvailable() && window_imp->mPreeditor)
             {
                 WINDOW_IMP_POST(window_imp->handleStartCompositionMessage());
@@ -2614,10 +2591,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_IME_ENDCOMPOSITION:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_IME_ENDCOMPOSITION");
-            if (debug_window_proc)
-            {
-                LL_INFOS() << "WM_IME_ENDCOMPOSITION" << LL_ENDL;
-            }
+            LL_INFOS("Window") << "WM_IME_ENDCOMPOSITION" << LL_ENDL;
             if (LLWinImm::isAvailable() && window_imp->mPreeditor)
             {
                 return 0;
@@ -2627,10 +2601,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_IME_COMPOSITION:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_IME_COMPOSITION");
-            if (debug_window_proc)
-            {
-                LL_INFOS() << "WM_IME_COMPOSITION" << LL_ENDL;
-            }
+            LL_INFOS("Window") << "WM_IME_COMPOSITION" << LL_ENDL;
             if (LLWinImm::isAvailable() && window_imp->mPreeditor)
             {
                 WINDOW_IMP_POST(window_imp->handleCompositionMessage(l_param));
@@ -2641,10 +2612,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_IME_REQUEST:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_IME_REQUEST");
-            if (debug_window_proc)
-            {
-                LL_INFOS() << "WM_IME_REQUEST" << LL_ENDL;
-            }
+            LL_INFOS("Window") << "WM_IME_REQUEST" << LL_ENDL;
             if (LLWinImm::isAvailable() && window_imp->mPreeditor)
             {
                 LRESULT result;
@@ -2673,12 +2641,9 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                     // it is worth trying.  The good old WM_CHAR works just fine even for supplementary
                     // characters.  We just need to take care of surrogate pairs sent as two WM_CHAR's
                     // by ourselves.  It is not that tough.  -- Alissa Sabre @ SL
-                    if (debug_window_proc)
-                    {
-                        LL_INFOS("Window") << "Debug WindowProc WM_CHAR "
-                            << " key " << S32(w_param)
-                            << LL_ENDL;
-                    }
+                    LL_INFOS("Window") << "Debug WindowProc WM_CHAR "
+                        << " key " << S32(w_param)
+                        << LL_ENDL;
                     // Even if LLWindowCallbacks::handleUnicodeChar(llwchar, BOOL) returned FALSE,
                     // we *did* processed the event, so I believe we should not pass it to DefWindowProc...
                     window_imp->handleUnicodeUTF16((U16)w_param, gKeyboard->currentMask(FALSE));
@@ -3006,19 +2971,17 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
             S32 height = S32(HIWORD(l_param));
 
             
-            if (debug_window_proc)
-            {
-                BOOL maximized = (w_param == SIZE_MAXIMIZED);
-                BOOL restored = (w_param == SIZE_RESTORED);
-                BOOL minimized = (w_param == SIZE_MINIMIZED);
-
-                LL_INFOS("Window") << "WINDOWPROC Size "
-                    << width << "x" << height
-                    << " max " << S32(maximized)
-                    << " min " << S32(minimized)
-                    << " rest " << S32(restored)
-                    << LL_ENDL;
-            }
+            LL_INFOS("Window");
+            BOOL maximized = (w_param == SIZE_MAXIMIZED);
+            BOOL restored = (w_param == SIZE_RESTORED);
+            BOOL minimized = (w_param == SIZE_MINIMIZED);
+
+            LL_CONT << "WINDOWPROC Size "
+                << width << "x" << height
+                << " max " << S32(maximized)
+                << " min " << S32(minimized)
+                << " rest " << S32(restored);
+            LL_ENDL;
 
             // There's an odd behavior with WM_SIZE that I would call a bug. If 
             // the window is maximized, and you call MoveWindow() with a size smaller
@@ -3084,10 +3047,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_SETFOCUS:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_SETFOCUS");
-            if (debug_window_proc)
-            {
-                LL_INFOS("Window") << "WINDOWPROC SetFocus" << LL_ENDL;
-            }
+            LL_INFOS("Window") << "WINDOWPROC SetFocus" << LL_ENDL;
             WINDOW_IMP_POST(window_imp->mCallbacks->handleFocus(window_imp));
             return 0;
         }
@@ -3095,10 +3055,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_KILLFOCUS:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_KILLFOCUS");
-            if (debug_window_proc)
-            {
-                LL_INFOS("Window") << "WINDOWPROC KillFocus" << LL_ENDL;
-            }
+            LL_INFOS("Window") << "WINDOWPROC KillFocus" << LL_ENDL;
             WINDOW_IMP_POST(window_imp->mCallbacks->handleFocusLost(window_imp));
             return 0;
         }
@@ -3219,10 +3176,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         default:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - default");
-            if (debug_window_proc)
-            {
-                LL_INFOS("Window") << "Unhandled windows message code: 0x" << std::hex << U32(u_msg) << LL_ENDL;
-            }
+            LL_INFOS("Window") << "Unhandled windows message code: 0x" << std::hex << U32(u_msg) << LL_ENDL;
         }
         break;
         }
-- 
cgit v1.2.3


From 026ef1935dbdb21ab79159d38fb78e126dd6ac95 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 8 May 2023 12:07:31 -0400
Subject: SL-19690: Follow up on Rye Mutt's fix for shutdown crashes.

Rather than continuing to propagate try/catch (Closed)
(aka LLThreadSafeQueueInterrupt) constructs through the code base, make
WorkQueueBase::post() return bool indicating success (i.e. ! isClosed()).
This obviates postIfOpen(), which no one was using anyway.

In effect, postIfOpen() is renamed post(), bypassing the exception when
isClosed().

Review existing try/catch blocks of that sort, changing to test for post()
returning false.
---
 indra/llwindow/llwindowwin32.cpp | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 43bef5ff68..c5a6a3fa8f 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -370,15 +370,10 @@ struct LLWindowWin32::LLWindowWin32Thread : public LL::ThreadPool
     template <typename CALLABLE>
     void post(CALLABLE&& func)
     {
-        try
-        {
-            getQueue().post(std::forward<CALLABLE>(func));
-        }
-        catch (const LLThreadSafeQueueInterrupt&)
-        {
-            // Shutdown timing is tricky. The main thread can end up trying
-            // to post a cursor position after having closed the WorkQueue.
-        }
+        // Ignore bool return. Shutdown timing is tricky: the main thread can
+        // end up trying to post a cursor position after having closed the
+        // WorkQueue.
+        getQueue().post(std::forward<CALLABLE>(func));
     }
 
     /**
-- 
cgit v1.2.3


From 3f1f1261869fbf0a40813b5492f49516e82af61a Mon Sep 17 00:00:00 2001
From: RunitaiLinden <davep@lindenlab.com>
Date: Mon, 8 May 2023 15:21:04 -0500
Subject: DRTVWR-559 Remove main window proc printf debugging.

---
 indra/llwindow/llwindowwin32.cpp | 66 +++-------------------------------------
 1 file changed, 4 insertions(+), 62 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 43bef5ff68..4530e34369 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -2281,13 +2281,8 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
     ASSERT_WINDOW_THREAD();
     LL_PROFILE_ZONE_SCOPED_CATEGORY_WIN32;
 
-    LL_DEBUGS("Window") << "mainWindowProc(" << std::hex << h_wnd
-                        << ", " << u_msg
-                        << ", " << w_param << ")" << std::dec << LL_ENDL;
-
     if (u_msg == WM_POST_FUNCTION_)
     {
-        LL_DEBUGS("Window") << "WM_POST_FUNCTION_" << LL_ENDL;
         // from LLWindowWin32Thread::Post()
         // Cast l_param back to the pointer to the heap FuncType
         // allocated by Post(). Capture in unique_ptr so we'll delete
@@ -2334,8 +2329,6 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_DEVICECHANGE:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_DEVICECHANGE");
-            LL_INFOS("Window") << "  WM_DEVICECHANGE: wParam=" << w_param
-                << "; lParam=" << l_param << LL_ENDL;
             if (w_param == DBT_DEVNODES_CHANGED || w_param == DBT_DEVICEARRIVAL)
             {
                 WINDOW_IMP_POST(window_imp->mCallbacks->handleDeviceChange(window_imp));
@@ -2397,13 +2390,6 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                 {
                     // This message should be sent whenever the app gains or loses focus.
                     BOOL activating = (BOOL)w_param;
-                    BOOL minimized = window_imp->getMinimized();
-
-                    LL_INFOS("Window") << "WINDOWPROC ActivateApp "
-                        << " activating " << S32(activating)
-                        << " minimized " << S32(minimized)
-                        << " fullscreen " << S32(window_imp->mFullscreen)
-                        << LL_ENDL;
 
                     if (window_imp->mFullscreen)
                     {
@@ -2438,20 +2424,10 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                     // Can be one of WA_ACTIVE, WA_CLICKACTIVE, or WA_INACTIVE
                     BOOL activating = (LOWORD(w_param) != WA_INACTIVE);
 
-                    BOOL minimized = BOOL(HIWORD(w_param));
-
                     if (!activating && LLWinImm::isAvailable() && window_imp->mPreeditor)
                     {
                         window_imp->interruptLanguageTextInput();
                     }
-
-                    // JC - I'm not sure why, but if we don't report that we handled the 
-                    // WM_ACTIVATE message, the WM_ACTIVATEAPP messages don't work 
-                    // properly when we run fullscreen.
-                    LL_INFOS("Window") << "WINDOWPROC Activate "
-                        << " activating " << S32(activating)
-                        << " minimized " << S32(minimized)
-                        << LL_ENDL;
                 });
             
             break;
@@ -2529,13 +2505,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                     window_imp->mRawWParam = w_param;
                     window_imp->mRawLParam = l_param;
 
-                    {
-                        LL_INFOS("Window") << "Debug WindowProc WM_KEYDOWN "
-                            << " key " << S32(w_param)
-                            << LL_ENDL;
-                        
-                        gKeyboard->handleKeyDown(w_param, mask);
-                    }
+                    gKeyboard->handleKeyDown(w_param, mask);
                 });
             if (eat_keystroke) return 0;    // skip DefWindowProc() handling if we're consuming the keypress 
             break;
@@ -2555,11 +2525,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                 window_imp->mRawLParam = l_param;
 
                 {
-                    LL_RECORD_BLOCK_TIME(FTM_KEYHANDLER);
-
-                    LL_INFOS("Window") << "Debug WindowProc WM_KEYUP "
-                        << " key " << S32(w_param)
-                        << LL_ENDL;
+                    LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_KEYUP");
                     gKeyboard->handleKeyUp(w_param, mask);
                 }
             });
@@ -2569,7 +2535,6 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_IME_SETCONTEXT:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_IME_SETCONTEXT");
-            LL_INFOS("Window") << "WM_IME_SETCONTEXT" << LL_ENDL;
             if (LLWinImm::isAvailable() && window_imp->mPreeditor)
             {
                 l_param &= ~ISC_SHOWUICOMPOSITIONWINDOW;
@@ -2580,7 +2545,6 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_IME_STARTCOMPOSITION:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_IME_STARTCOMPOSITION");
-            LL_INFOS("Window") << "WM_IME_STARTCOMPOSITION" << LL_ENDL;
             if (LLWinImm::isAvailable() && window_imp->mPreeditor)
             {
                 WINDOW_IMP_POST(window_imp->handleStartCompositionMessage());
@@ -2591,7 +2555,6 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_IME_ENDCOMPOSITION:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_IME_ENDCOMPOSITION");
-            LL_INFOS("Window") << "WM_IME_ENDCOMPOSITION" << LL_ENDL;
             if (LLWinImm::isAvailable() && window_imp->mPreeditor)
             {
                 return 0;
@@ -2601,7 +2564,6 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_IME_COMPOSITION:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_IME_COMPOSITION");
-            LL_INFOS("Window") << "WM_IME_COMPOSITION" << LL_ENDL;
             if (LLWinImm::isAvailable() && window_imp->mPreeditor)
             {
                 WINDOW_IMP_POST(window_imp->handleCompositionMessage(l_param));
@@ -2612,7 +2574,6 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_IME_REQUEST:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_IME_REQUEST");
-            LL_INFOS("Window") << "WM_IME_REQUEST" << LL_ENDL;
             if (LLWinImm::isAvailable() && window_imp->mPreeditor)
             {
                 LRESULT result;
@@ -2641,9 +2602,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
                     // it is worth trying.  The good old WM_CHAR works just fine even for supplementary
                     // characters.  We just need to take care of surrogate pairs sent as two WM_CHAR's
                     // by ourselves.  It is not that tough.  -- Alissa Sabre @ SL
-                    LL_INFOS("Window") << "Debug WindowProc WM_CHAR "
-                        << " key " << S32(w_param)
-                        << LL_ENDL;
+                    
                     // Even if LLWindowCallbacks::handleUnicodeChar(llwchar, BOOL) returned FALSE,
                     // we *did* processed the event, so I believe we should not pass it to DefWindowProc...
                     window_imp->handleUnicodeUTF16((U16)w_param, gKeyboard->currentMask(FALSE));
@@ -2967,21 +2926,6 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_SIZE");
             window_imp->updateWindowRect();
-            S32 width = S32(LOWORD(l_param));
-            S32 height = S32(HIWORD(l_param));
-
-            
-            LL_INFOS("Window");
-            BOOL maximized = (w_param == SIZE_MAXIMIZED);
-            BOOL restored = (w_param == SIZE_RESTORED);
-            BOOL minimized = (w_param == SIZE_MINIMIZED);
-
-            LL_CONT << "WINDOWPROC Size "
-                << width << "x" << height
-                << " max " << S32(maximized)
-                << " min " << S32(minimized)
-                << " rest " << S32(restored);
-            LL_ENDL;
 
             // There's an odd behavior with WM_SIZE that I would call a bug. If 
             // the window is maximized, and you call MoveWindow() with a size smaller
@@ -3047,7 +2991,6 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_SETFOCUS:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_SETFOCUS");
-            LL_INFOS("Window") << "WINDOWPROC SetFocus" << LL_ENDL;
             WINDOW_IMP_POST(window_imp->mCallbacks->handleFocus(window_imp));
             return 0;
         }
@@ -3055,7 +2998,6 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         case WM_KILLFOCUS:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - WM_KILLFOCUS");
-            LL_INFOS("Window") << "WINDOWPROC KillFocus" << LL_ENDL;
             WINDOW_IMP_POST(window_imp->mCallbacks->handleFocusLost(window_imp));
             return 0;
         }
@@ -3176,7 +3118,7 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_
         default:
         {
             LL_PROFILE_ZONE_NAMED_CATEGORY_WIN32("mwp - default");
-            LL_INFOS("Window") << "Unhandled windows message code: 0x" << std::hex << U32(u_msg) << LL_ENDL;
+            LL_DEBUGS("Window") << "Unhandled windows message code: 0x" << std::hex << U32(u_msg) << LL_ENDL;
         }
         break;
         }
-- 
cgit v1.2.3


From cb8c91ffc8e6c40dfd6cb86922ac3c6968855466 Mon Sep 17 00:00:00 2001
From: Brad Linden <brad@lindenlab.com>
Date: Thu, 15 Jun 2023 14:39:05 -0700
Subject: SL-19881 fix assertion failure in [NSEvent characters]

---
 indra/llwindow/llopenglview-objc.mm | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llopenglview-objc.mm b/indra/llwindow/llopenglview-objc.mm
index 9d497691d8..586e00b5e4 100644
--- a/indra/llwindow/llopenglview-objc.mm
+++ b/indra/llwindow/llopenglview-objc.mm
@@ -550,7 +550,16 @@ attributedStringInfo getSegments(NSAttributedString *str)
     if (mModifiers & mask)
     {
         eventData.mKeyEvent = NativeKeyEventData::KEYDOWN;
-        callKeyDown(&eventData, [theEvent keyCode], 0, [[theEvent characters] characterAtIndex:0]);
+
+        wchar_t c = 0;
+        if([theEvent type] == NSEventTypeKeyDown)
+        {
+            // characters property is only valid when the event is of type KeyDown or KeyUp
+            // https://developer.apple.com/documentation/appkit/nsevent/1534183-characters?language=objc
+            c = [[theEvent characters] characterAtIndex:0];
+        }
+
+        callKeyDown(&eventData, [theEvent keyCode], 0, c);
     }
     else
     {
-- 
cgit v1.2.3


From 5b2de090c1ac44c415e8573e0d6b1136cd689f35 Mon Sep 17 00:00:00 2001
From: Cosmic Linden <cosmic@lindenlab.com>
Date: Mon, 18 Sep 2023 17:05:45 -0700
Subject: SL-20177: Blind attempt at fixing crash in SetWindowLongPtr. Guess
 based on the fact that crashes started around the time VRAM accounting was
 added.

---
 indra/llwindow/llwindowwin32.cpp | 28 +++++++++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 1f91cbbaa8..42ec4ee29d 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -352,6 +352,11 @@ struct LLWindowWin32::LLWindowWin32Thread : public LL::ThreadPool
 
     void run() override;
 
+    void glReady()
+    {
+        mGLReady = true;
+    }
+
     // initialzie DXGI adapter (for querying available VRAM)
     void initDX();
     
@@ -410,6 +415,9 @@ struct LLWindowWin32::LLWindowWin32Thread : public LL::ThreadPool
     HWND mWindowHandle = NULL;
     HDC mhDC = 0;
 
+    // *HACK: Attempt to prevent startup crashes by deferring memory accounting
+    // until after some graphics setup. See SL-20177. -Cosmic,2023-09-18
+    bool mGLReady = false;
     // best guess at available video memory in MB
     std::atomic<U32> mAvailableVRAM;
 
@@ -1720,6 +1728,13 @@ const	S32   max_format  = (S32)num_formats - 1;
 	// ok to post quit messages now
 	mPostQuit = TRUE;
 
+    // *HACK: Attempt to prevent startup crashes by deferring memory accounting
+    // until after some graphics setup. See SL-20177. -Cosmic,2023-09-18
+    mWindowThread->post([=]()
+    {
+        mWindowThread->glReady();
+    });
+
 	if (auto_show)
 	{
 		show();
@@ -4692,6 +4707,8 @@ void debugEnumerateGraphicsAdapters()
 
 void LLWindowWin32::LLWindowWin32Thread::initDX()
 {
+    if (!mGLReady) { return; }
+
     if (mDXGIAdapter == NULL)
     {
         debugEnumerateGraphicsAdapters();
@@ -4726,6 +4743,8 @@ void LLWindowWin32::LLWindowWin32Thread::initDX()
 
 void LLWindowWin32::LLWindowWin32Thread::initD3D()
 {
+    if (!mGLReady) { return; }
+
     if (mDXGIAdapter == NULL && mD3DDevice == NULL && mWindowHandle != 0)
     {
         mD3D = Direct3DCreate9(D3D_SDK_VERSION);
@@ -4752,6 +4771,8 @@ void LLWindowWin32::LLWindowWin32Thread::initD3D()
 void LLWindowWin32::LLWindowWin32Thread::updateVRAMUsage()
 {
     LL_PROFILE_ZONE_SCOPED;
+    if (!mGLReady) { return; }
+
     if (mDXGIAdapter != nullptr)
     {
         // NOTE: what lies below is hand wavy math based on compatibility testing and observation against a variety of hardware
@@ -4825,8 +4846,6 @@ void LLWindowWin32::LLWindowWin32Thread::run()
     sWindowThreadId = std::this_thread::get_id();
     LogChange logger("Window");
 
-    initDX();
-
     //as good a place as any to up the MM timer resolution (see ms_sleep)
     //attempt to set timer resolution to 1ms
     TIMECAPS tc;
@@ -4839,9 +4858,12 @@ void LLWindowWin32::LLWindowWin32Thread::run()
     {
         LL_PROFILE_ZONE_SCOPED_CATEGORY_WIN32;
 
+        // lazily call initD3D inside this loop to catch when mGLReady has been set to true
+        initDX();
+
         if (mWindowHandle != 0)
         {
-            // lazily call initD3D inside this loop to catch when mWindowHandle has been set
+            // lazily call initD3D inside this loop to catch when mWindowHandle has been set, and mGLReady has been set to true
             // *TODO: Shutdown if this fails when mWindowHandle exists
             initD3D();
 
-- 
cgit v1.2.3


From 65fb4e67cb55f048c3ac8d0e46fc585f737c48ad Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Thu, 2 Nov 2023 10:47:15 -0500
Subject: SL-19979 Fix for frame stalls on mac with shadows enabled.  Also fix
 multihreaded GL not working on mac (thanks, Rye!)

---
 indra/llwindow/llwindowmacosx.cpp | 54 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 52 insertions(+), 2 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowmacosx.cpp b/indra/llwindow/llwindowmacosx.cpp
index 8bfaeca614..b99af1ae4c 100644
--- a/indra/llwindow/llwindowmacosx.cpp
+++ b/indra/llwindow/llwindowmacosx.cpp
@@ -186,7 +186,7 @@ LLWindowMacOSX::LLWindowMacOSX(LLWindowCallbacks* callbacks,
 			return;
 		}
 
-		//start with arrow cursor
+        //start with arrow cursor
 		initCursors();
 		setCursor( UI_CURSOR_ARROW );
 		
@@ -637,6 +637,34 @@ BOOL LLWindowMacOSX::createContext(int x, int y, int width, int height, int bits
 		mGLView = createOpenGLView(mWindow, mFSAASamples, enable_vsync);
 		mContext = getCGLContextObj(mGLView);
 		gGLManager.mVRAM = getVramSize(mGLView);
+
+        if(!mPixelFormat)
+        {
+            CGLPixelFormatAttribute attribs[] =
+            {
+                kCGLPFANoRecovery,
+                kCGLPFADoubleBuffer,
+                kCGLPFAClosestPolicy,
+                kCGLPFAAccelerated,
+                kCGLPFAMultisample,
+                kCGLPFASampleBuffers, static_cast<CGLPixelFormatAttribute>((mFSAASamples > 0 ? 1 : 0)),
+                kCGLPFASamples, static_cast<CGLPixelFormatAttribute>(mFSAASamples),
+                kCGLPFAStencilSize, static_cast<CGLPixelFormatAttribute>(8),
+                kCGLPFADepthSize, static_cast<CGLPixelFormatAttribute>(24),
+                kCGLPFAAlphaSize, static_cast<CGLPixelFormatAttribute>(8),
+                kCGLPFAColorSize, static_cast<CGLPixelFormatAttribute>(24),
+                kCGLPFAOpenGLProfile, static_cast<CGLPixelFormatAttribute>(kCGLOGLPVersion_GL4_Core),
+                static_cast<CGLPixelFormatAttribute>(0)
+            };
+
+            GLint numPixelFormats;
+            CGLChoosePixelFormat (attribs, &mPixelFormat, &numPixelFormats);
+            
+            if(mPixelFormat == NULL) {
+                CGLChoosePixelFormat (attribs, &mPixelFormat, &numPixelFormats);
+            }
+        }
+
 	}
 	
 	// This sets up our view to recieve text from our non-inline text input window.
@@ -1934,7 +1962,10 @@ public:
 void* LLWindowMacOSX::createSharedContext()
 {
     sharedContext* sc = new sharedContext();
-    CGLCreateContext(mPixelFormat, mContext, &(sc->mContext));
+    CGLError err = CGLCreateContext(mPixelFormat, mContext, &(sc->mContext));
+    llassert(err == kCGLNoError);
+
+    CGLEnable(mContext, kCGLCEMPEngine);
 
     return (void *)sc;
 }
@@ -1942,6 +1973,25 @@ void* LLWindowMacOSX::createSharedContext()
 void LLWindowMacOSX::makeContextCurrent(void* context)
 {
     CGLSetCurrentContext(((sharedContext*)context)->mContext);
+
+    //enable multi-threaded OpenGL
+	if (sUseMultGL)
+	{
+		CGLError cgl_err;
+		CGLContextObj ctx = CGLGetCurrentContext();
+
+		cgl_err =  CGLEnable( ctx, kCGLCEMPEngine);
+
+		if (cgl_err != kCGLNoError )
+		{
+			LL_INFOS("GLInit") << "Multi-threaded OpenGL not available." << LL_ENDL;
+		}
+		else
+		{
+            LL_INFOS("GLInit") << "Multi-threaded OpenGL enabled." << LL_ENDL;
+		}
+	}
+	
 }
 
 void LLWindowMacOSX::destroySharedContext(void* context)
-- 
cgit v1.2.3


From 70721bae390ab49ff24022c5c8f75bc274adc8c8 Mon Sep 17 00:00:00 2001
From: Dave Parks <davep@lindenlab.com>
Date: Fri, 3 Nov 2023 11:15:19 -0500
Subject: DRTVWR-559 Fix for mac build.

---
 indra/llwindow/llwindowmacosx.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'indra/llwindow')

diff --git a/indra/llwindow/llwindowmacosx.cpp b/indra/llwindow/llwindowmacosx.cpp
index b99af1ae4c..778e5d3898 100644
--- a/indra/llwindow/llwindowmacosx.cpp
+++ b/indra/llwindow/llwindowmacosx.cpp
@@ -1962,10 +1962,12 @@ public:
 void* LLWindowMacOSX::createSharedContext()
 {
     sharedContext* sc = new sharedContext();
-    CGLError err = CGLCreateContext(mPixelFormat, mContext, &(sc->mContext));
-    llassert(err == kCGLNoError);
-
-    CGLEnable(mContext, kCGLCEMPEngine);
+    CGLCreateContext(mPixelFormat, mContext, &(sc->mContext));
+    
+    if (sUseMultGL)
+    {
+        CGLEnable(mContext, kCGLCEMPEngine);
+    }
 
     return (void *)sc;
 }
-- 
cgit v1.2.3