Merged in SL-17219 (pull request #992)

SL-17219

6 files changed, 220 insertions, 66 deletions

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..2c538a60c9 100644
--- a/indra/llwindow/llwindow.h
+++ b/indra/llwindow/llwindow.h
@@ -162,7 +162,10 @@ public:
 	virtual F32	getNativeAspectRatio() = 0;
 	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..2f2c0de5bd 100644
--- a/indra/llwindow/llwindowheadless.h
+++ b/indra/llwindow/llwindowheadless.h
@@ -32,72 +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 {}
 
-	/*virtual*/ void *getPlatformWindow() { return 0; };
-	/*virtual*/ void bringToFront() {};
+    U32 getAvailableVRAMMegabytes() override { return 4096; }
+
+	/*virtual*/ void *getPlatformWindow() override { return 0; }
+	/*virtual*/ void bringToFront() override {}
 	
 	LLWindowHeadless(LLWindowCallbacks* callbacks,
 		const std::string& title, const std::string& name,
@@ -113,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 {}
 
 };
 
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;
 
diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index 1f3823509c..da79660239 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;
 };
 
 
@@ -4515,6 +4540,10 @@ std::vector<std::string> LLWindowWin32::getDynamicFallbackFontList()
 	return std::vector<std::string>();
 }
 
+U32 LLWindowWin32::getAvailableVRAMMegabytes()
+{
+    return mWindowThread ? mWindowThread->getAvailableVRAMMegabytes() : 0;
+}
 
 #endif // LL_WINDOWS
 
@@ -4570,17 +4599,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)
@@ -4613,6 +4722,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");
@@ -4621,6 +4737,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();