first bfi alpha

Author: mausimus

ShaderGC/ShaderGC.cpp

@@ -251,6 +251,8 @@ void ShaderGC::ProcessSourceShader(SourceShaderDef& def, ostream& log, bool& war
     def.params.push_back(SourceShaderParam("OriginalSize", 4, 0));
     def.params.push_back(SourceShaderParam("OutputSize", 4, 0));
     def.params.push_back(SourceShaderParam("FrameCount", 1, 0));
+    def.params.push_back(SourceShaderParam("CurrentSubFrame", 1, 0));
+    def.params.push_back(SourceShaderParam("TotalSubFrames", 1, 0));
 }
 
 int GetSize(const std::string& mtype)

ShaderGlass/BrowserWindow.cpp

@@ -402,14 +402,14 @@ void BrowserWindow::Build()
 
     AddItemToTree(m_treeControl, convertCharArrayToLPCWSTR("Community Favorites"), -1, 1);
 
-    for(int fp = 0; fp < sizeof(favoritePresets) / sizeof(const char*); fp++)
+    /*for(int fp = 0; fp < sizeof(favoritePresets) / sizeof(const char*); fp++)
     {
         auto p = m_captureManager.FindByName(favoritePresets[fp]);
         if(p != -1)
         {
             m_favorites[WM_SHADER(p)] = AddItemToTree(m_treeControl, convertCharArrayToLPCWSTR(favoritePresets[fp]), WM_SHADER(p), 2);
         }
-    }
+    }*/
 
     auto raItem = AddItemToTree(m_treeControl, convertCharArrayToLPCWSTR("RetroArch Library"), -1, 1);
 

ShaderGlass/CaptureManager.cpp

@@ -158,6 +158,7 @@ bool CaptureManager::StartSession()
     UpdateLockedArea();
     UpdateCroppedArea();
     UpdateVertical();
+    UpdateSubFrames();
 
     if(m_options.imageFile.size())
     {
@@ -212,7 +213,8 @@ bool CaptureManager::StartSession()
     }
 
     m_active = true;
-    CreateThread(NULL, 0, ThreadFuncProxy, this, 0, NULL);
+    auto thread = CreateThread(NULL, 0, ThreadFuncProxy, this, 0, NULL);
+    SetThreadPriority(thread, THREAD_PRIORITY_TIME_CRITICAL);
 
     UpdateCursor();
     return true;
@@ -428,6 +430,14 @@ void CaptureManager::UpdateVertical()
     }
 }
 
+void CaptureManager::UpdateSubFrames()
+{
+    if(m_shaderGlass)
+    {
+        m_shaderGlass->SetSubFrames(m_options.subFrames);
+    }
+}
+
 void CaptureManager::GrabOutput()
 {
     if(m_shaderGlass)
@@ -465,7 +475,7 @@ void CaptureManager::ThreadFunc()
 {
     while(m_active)
     {
-        WaitForSingleObject(m_frameEvent, 1);
+        //WaitForSingleObject(m_frameEvent, 1);
         ProcessFrame();
     }
 }

ShaderGlass/CaptureManager.h

@@ -42,6 +42,7 @@ struct CaptureOptions
     bool         useHDR {false};
     RECT         croppedArea {0, 0, 0, 0};
     bool         vertical {false};
+    unsigned     subFrames {0};
 };
 
 class CaptureManager
@@ -75,6 +76,7 @@ class CaptureManager
     void  UpdateLockedArea();
     void  UpdateCroppedArea();
     void  UpdateVertical();
+    void  UpdateSubFrames();
     void  GrabOutput();
     void  UpdateParams();
     void  ResetParams();

ShaderGlass/CaptureSession.cpp

@@ -79,7 +79,7 @@ void CaptureSession::Reset()
     m_numInputFrames  = 0;
     m_prevInputFrames = 0;
     m_fps             = 0;
-    m_prevTicks       = GetTickCount64();
+    m_prevTicks       = GetTicks();
 }
 
 void CaptureSession::UpdateCursor(bool captureCursor)
@@ -107,13 +107,13 @@ void CaptureSession::OnFrameArrived(winrt::Direct3D11CaptureFramePool const& sen
 
 void CaptureSession::OnInputFrame()
 {
-    m_frameTicks = GetTickCount64();
+    m_frameTicks = GetTicks();
     m_numInputFrames++;
-    if(m_frameTicks - m_prevTicks > 1000)
+    if(m_frameTicks - m_prevTicks > TICKS_PER_SEC)
     {
         auto deltaTicks   = m_frameTicks - m_prevTicks;
         auto deltaFrames  = m_numInputFrames - m_prevInputFrames;
-        m_fps             = deltaFrames * 1000.0f / deltaTicks;
+        m_fps             = deltaFrames * (float)TICKS_PER_SEC / deltaTicks;
         m_prevInputFrames = m_numInputFrames;
         m_prevTicks       = m_frameTicks;
     }

ShaderGlass/Helpers.cpp

@@ -108,3 +108,22 @@ bool CanUpdateCursor()
         return false;
     }
 }
+
+int32_t GetTicks()
+{
+    static LARGE_INTEGER freq {.QuadPart = 0};
+    static LARGE_INTEGER startTicks {.QuadPart = 0};
+    if(freq.QuadPart == 0)
+    {
+        QueryPerformanceFrequency(&freq);
+        QueryPerformanceCounter(&startTicks);
+    }
+
+    LARGE_INTEGER ticks;
+    if(!QueryPerformanceCounter(&ticks) || freq.QuadPart == 0)
+    {
+        return GetTickCount64();
+    }
+
+    return (int32_t)((ticks.QuadPart - startTicks.QuadPart) / (freq.QuadPart / TICKS_PER_SEC));
+}

ShaderGlass/Helpers.h

@@ -9,12 +9,16 @@ GNU General Public License v3.0
 
 #define MAX_WINDOW_TITLE 200
 #define MAX_DEVICE_NAME 200
+#define TICKS_PER_SEC 10000
+#define REFERENCE_FPS 59.95
+#define REFERENCE_FRAME_TIME (TICKS_PER_SEC / REFERENCE_FPS)
 
-wchar_t* convertCharArrayToLPCWSTR(const char* charArray);
-BOOL IsAltTabWindow(HWND hwnd);
+wchar_t*     convertCharArrayToLPCWSTR(const char* charArray);
+BOOL         IsAltTabWindow(HWND hwnd);
 std::wstring GetWindowStringText(HWND hwnd);
-bool HasCaptureAPI();
-bool Is1903();
-bool CanDisableBorder();
-bool CanSetCaptureRate();
-bool CanUpdateCursor();
+bool         HasCaptureAPI();
+bool         Is1903();
+bool         CanDisableBorder();
+bool         CanSetCaptureRate();
+bool         CanUpdateCursor();
+int32_t      GetTicks();

ShaderGlass/Options.h

@@ -17,6 +17,7 @@ GNU General Public License v3.0
 #define MAX_CAPTURE_DEVICE_FORMATS 1024U
 #define MAX_RECENT_PROFILES 20U
 #define MAX_RECENT_IMPORTS 20U
+#define MAX_SUBFRAMES 10U
 
 #define WM_PIXEL_SIZE(i) (static_cast<UINT>(WM_USER) + i)
 #define WM_ASPECT_RATIO(i) (static_cast<UINT> WM_PIXEL_SIZE(MAX_PIXEL_SIZES) + i)
@@ -28,6 +29,7 @@ GNU General Public License v3.0
 #define WM_RECENT_PROFILE(i) (static_cast<UINT> WM_CAPTURE_DISPLAY(MAX_CAPTURE_DISPLAYS) + i)
 #define WM_RECENT_IMPORT(i) (static_cast<UINT> WM_RECENT_PROFILE(MAX_RECENT_PROFILES) + i)
 #define WM_CAPTURE_DEVICE_FORMAT(i) (static_cast<UINT> WM_RECENT_IMPORT(MAX_RECENT_IMPORTS) + i)
+#define WM_SUBFRAMES(i) (static_cast<UINT> WM_CAPTURE_DEVICE_FORMAT(MAX_CAPTURE_DEVICE_FORMATS) + i)
 
 #define CUSTOM_MNEMONIC "Custom"
 
@@ -59,6 +61,15 @@ struct FrameSkipInfo
     FrameSkipInfo(int s, LPCWSTR text, const char* mnemonic) : s(s), text(text), mnemonic(mnemonic) { }
 };
 
+struct SubFrameInfo
+{
+    unsigned    s;
+    LPCWSTR     text;
+    const char* mnemonic;
+
+    SubFrameInfo(int s, LPCWSTR text, const char* mnemonic) : s(s), text(text), mnemonic(mnemonic) { }
+};
+
 struct OutputScaleInfo
 {
     float       s;
@@ -132,6 +143,15 @@ static const std::map<UINT, PixelSizeInfo> pixelSizes = {{WM_PIXEL_SIZE(0), Pixe
                                                          {WM_PIXEL_SIZE(13), PixelSizeInfo(10.0f, 10.0f, L"x10", "10")},
                                                          {WM_PIXEL_SIZE(14), PixelSizeInfo(10.8f, 10.8f, L"x10.8 (200p -> 4K)", "10.8")}};
 
+static const std::map<UINT, SubFrameInfo> subFrames = {{WM_SUBFRAMES(0), SubFrameInfo(0, L"disabled", "0")},
+                                                       {WM_SUBFRAMES(1), SubFrameInfo(2, L"2 (120 Hz)", "2")},
+                                                       {WM_SUBFRAMES(2), SubFrameInfo(3, L"3 (180 Hz)", "3")},
+                                                       {WM_SUBFRAMES(3), SubFrameInfo(4, L"4 (240 Hz)", "4")},
+                                                       {WM_SUBFRAMES(4), SubFrameInfo(5, L"5 (300 Hz)", "5")},
+                                                       {WM_SUBFRAMES(5), SubFrameInfo(6, L"6 (360 Hz)", "6")},
+                                                       {WM_SUBFRAMES(6), SubFrameInfo(7, L"7 (420 Hz)", "7")},
+                                                       {WM_SUBFRAMES(7), SubFrameInfo(8, L"8 (480 Hz)", "8")}};
+
 static std::map<UINT, AspectRatioInfo> aspectRatios = {
     {WM_ASPECT_RATIO(0), AspectRatioInfo(1.0f, L"None", "1")},
     {WM_ASPECT_RATIO(1), AspectRatioInfo(1.2f, L"x1.2 (DOS, NTSC)", "1.2")},
@@ -173,25 +193,5 @@ static const std::map<UINT, OutputScaleInfo> outputScales = {{WM_OUTPUT_SCALE(0)
                                                              {WM_OUTPUT_SCALE(11), OutputScaleInfo(9.0f, L"900%", "900")},
                                                              {WM_OUTPUT_SCALE(12), OutputScaleInfo(10.0f, L"1000%", "1000")}};
 
-static const char* defaultPreset     = "newpixie-crt";
-static const char* favoritePresets[] = {"bayer_4x4",
-                                        "crt-geom",
-                                        "crt-guest-advanced-ntsc",
-                                        "crt-mattias",
-                                        "crt-royale",
-                                        "ega",
-                                        "fxaa",
-                                        "gb-pocket",
-                                        "gtu-v050",
-                                        "kawase_glow",
-                                        "MegaBezel_STD",
-                                        "MMJ_Cel_Shader",
-                                        "newpixie-crt",
-                                        "ntsc-vcr",
-                                        "pal-r57shell",
-                                        "scalefx",
-                                        "scanline",
-                                        "supereagle",
-                                        "technicolor",
-                                        "uborder-bezel-reflections",
-                                        "vhs"};
+static const char* defaultPreset     = "crt-beam-simulator";
+//static const char* favoritePresets[] = {};

ShaderGlass/ParamsWindow.cpp

@@ -253,6 +253,10 @@ void ParamsWindow::RebuildControls(bool doResize)
             int startValue = (int)roundf(numSteps * (p->currentValue - p->minValue) / (p->maxValue - p->minValue));
             AddTrackbar(0, numSteps, startValue, numSteps, p->name.c_str(), p);
         }
+        else
+        {
+            AddTrackbar(0, 0, 0, 0, p->name.c_str(), p);
+        }
     }
 
     if(m_trackbars.size())
@@ -415,10 +419,11 @@ void ParamsWindow::AddTrackbar(UINT iMin, UINT iMax, UINT iStart, UINT iSteps, c
         }
     }
 
+    int exStyle = iMin == iMax ? WS_DISABLED : 0;
     auto hwndTrack = CreateWindowEx(0,
                                     TRACKBAR_CLASS,
                                     L"Trackbar Control",
-                                    WS_CHILD | WS_VISIBLE | TBS_AUTOTICKS,
+                                    WS_CHILD | WS_VISIBLE | TBS_AUTOTICKS | exStyle,
                                     (LONG)(m_dpiScale * STATIC_WIDTH),
                                     (LONG)(m_dpiScale * (m_trackbars.size() * PARAM_HEIGHT + PARAMS_TOP)),
                                     (LONG)(m_dpiScale * TRACK_WIDTH),