initial shader work

all code is remarked

Author: zjoasan

Common/Include/AdapterOption.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) {
@@ -132,6 +226,12 @@ class AdapterOption {
     bool hasTargetAdapter{}; // Indicates if a target adapter is selected
     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() {
@@ -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) {