DO NOT COMMIT in current state read msg

Common/Include/AdapterOption.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <wrl/client.h> 	// For ComPtr
-#include <dxgi.h>       	// For IDXGIAdapter, IDXGIFactory1
-#include <algorithm>    	// For sort
+#include <wrl/client.h>     // For ComPtr
+#include <dxgi.h>           // For IDXGIAdapter, IDXGIFactory1
+#include <algorithm>        // For sort
 #include <setupapi.h>
 #include <devguid.h>
 #include <devpropdef.h>
@@ -65,6 +65,100 @@ vector<GPUInfo> getAvailableGPUs() {
     return gpus;
 }
 
+// #--- // Find the integrated GPU (iGPU) from available adapters
+// #--- // Returns optional LUID if iGPU is found, nullopt otherwise
+// #--- inline std::optional<LUID> findiGPU() {
+// #---     auto gpus = getAvailableGPUs();
+// #---     if (gpus.empty()) {
+// #---         return std::nullopt;
+// #---     }
+// #--- 
+// #---     // iGPU detection criteria:
+// #---     // 1. Not a software adapter (has dedicated video memory > 0)
+// #---     // 2. Low dedicated video memory (typically < 512MB for integrated)
+// #---     // 3. Usually Intel HD/UHD graphics (Vendor ID 0x8086) or AMD APU (Vendor ID 0x1002)
+// #---     // 4. Often the GPU with least dedicated memory (excluding software adapters)
+// #--- 
+// #---     const UINT64 iGPUMemoryThreshold = 512ULL * 1024ULL * 1024ULL; // 512MB threshold
+// #---     const UINT intelVendorId = 0x8086;  // Intel
+// #---     const UINT amdVendorId = 0x1002;    // AMD (for APUs)
+// #--- 
+// #---     std::optional<LUID> iGPULuid = std::nullopt;
+// #---     UINT64 minDedicatedMemory = UINT64_MAX;
+// #---     const GPUInfo* candidateGPU = nullptr;
+// #--- 
+// #---     // First pass: Look for Intel or AMD integrated graphics with low memory
+// #---     for (const auto& gpu : gpus) {
+// #---         const auto& desc = gpu.desc;
+// #--- 
+// #---         // Skip software adapters (zero dedicated memory)
+// #---         if (desc.DedicatedVideoMemory == 0) {
+// #---             continue;
+// #---         }
+// #--- 
+// #---         // Check for integrated GPU characteristics
+// #---         bool isLikelyiGPU = false;
+// #--- 
+// #---         // Check by vendor ID (Intel or AMD APU)
+// #---         if (desc.VendorId == intelVendorId || desc.VendorId == amdVendorId) {
+// #---             // Intel HD/UHD graphics typically have specific naming patterns
+// #---             wstring name = desc.Description;
+// #---             if (name.find(L"Intel") != wstring::npos &&
+// #---                 (name.find(L"HD") != wstring::npos || name.find(L"UHD") != wstring::npos)) {
+// #---                 isLikelyiGPU = true;
+// #---             }
+// #---             // Check if it has low dedicated memory (typical for iGPU)
+// #---             if (desc.DedicatedVideoMemory < iGPUMemoryThreshold) {
+// #---                 isLikelyiGPU = true;
+// #---             }
+// #---         }
+// #--- 
+// #---         // Track the GPU with least dedicated memory (usually iGPU)
+// #---         if (desc.DedicatedVideoMemory < minDedicatedMemory) {
+// #---             minDedicatedMemory = desc.DedicatedVideoMemory;
+// #---             // Prioritize Intel/AMD candidates, but also consider low memory GPUs
+// #---             if (isLikelyiGPU || desc.DedicatedVideoMemory < iGPUMemoryThreshold) {
+// #---                 candidateGPU = &gpu;
+// #---             }
+// #---         }
+// #---     }
+// #--- 
+// #---     // If we found a candidate with Intel/AMD or low memory, return it
+// #---     if (candidateGPU != nullptr) {
+// #---         return candidateGPU->desc.AdapterLuid;
+// #---     }
+// #--- 
+// #---     // Fallback: If no clear iGPU found by vendor, return the GPU with least memory
+// #---     // (assuming discrete GPUs typically have more memory)
+// #---     if (minDedicatedMemory != UINT64_MAX && minDedicatedMemory < iGPUMemoryThreshold) {
+// #---         for (const auto& gpu : gpus) {
+// #---             if (gpu.desc.DedicatedVideoMemory == minDedicatedMemory) {
+// #---                 return gpu.desc.AdapterLuid;
+// #---             }
+// #---         }
+// #---     }
+// #--- 
+// #---     return std::nullopt;
+// #--- }
+
+// #--- // Get iGPU name if available
+// #--- inline wstring getiGPUName() {
+// #---     auto luidOpt = findiGPU();
+// #---     if (!luidOpt.has_value()) {
+// #---         return L"";
+// #---     }
+// #--- 
+// #---     auto gpus = getAvailableGPUs();
+// #---     for (const auto& gpu : gpus) {
+// #---         if (gpu.desc.AdapterLuid.LowPart == luidOpt.value().LowPart &&
+// #---             gpu.desc.AdapterLuid.HighPart == luidOpt.value().HighPart) {
+// #---             return gpu.name;
+// #---         }
+// #---     }
+// #--- 
+// #---     return L"";
+// #--- }
+
 // Resolve an adapter LUID from a PCI bus number by enumerating display devices (SetupAPI).
 // Returns nullopt if no match is found or if the system doesn't expose the LUID property.
 inline std::optional<LUID> ResolveAdapterLuidFromPciBus(uint32_t targetBusIndex) {
@@ -133,6 +227,12 @@ class AdapterOption {
     LUID adapterLuid{};      // Adapter's unique identifier (LUID)
     wstring target_name{};   // Target adapter name
 
+// #---     // --- iGPU SUPPORT ---
+// #---     bool hasiGPU{};          // Indicates if an iGPU was detected
+// #---     LUID iGPULuid{};         // Integrated GPU's unique identifier (LUID)
+// #---     wstring iGPU_name{};     // Integrated GPU name
+// #---     // --- END iGPU SUPPORT ---
+
     // Select the best GPU based on dedicated video memory
     wstring selectBestGPU() {
         auto gpus = getAvailableGPUs();
@@ -187,6 +287,40 @@ class AdapterOption {
         }
     }
 
+// #---     // --- iGPU DETECTION METHODS ---
+// #---     // Detect and select the integrated GPU (iGPU)
+// #---     // Returns true if iGPU is found and set, false otherwise
+// #---     bool selectiGPU() {
+// #---         auto luidOpt = findiGPU();
+// #---         if (luidOpt.has_value()) {
+// #---             iGPULuid = luidOpt.value();
+// #---             iGPU_name = getiGPUName();
+// #---             hasiGPU = true;
+// #---             return true;
+// #---         }
+// #---         hasiGPU = false;
+// #---         return false;
+// #---     }
+// #---
+// #---     // Get the iGPU LUID if available
+// #---     std::optional<LUID> getiGPULuid() const {
+// #---         if (hasiGPU) {
+// #---             return iGPULuid;
+// #---         }
+// #---         return std::nullopt;
+// #---     }
+// #---
+// #---     // Check if iGPU is available
+// #---     bool hasIntegratedGPU() const {
+// #---         return hasiGPU;
+// #---     }
+// #---
+// #---     // Get iGPU name
+// #---     wstring getiGPUName() const {
+// #---         return iGPU_name;
+// #---     }
+// #---     // --- END iGPU DETECTION METHODS ---
+
 private:
     // Find and set the adapter by name, optionally using "name,bus" where bus is the PCI bus number.
     bool findAndSetAdapter(const wstring& adapterSpec) {