RenderDoc.cpp

Go to the documentation of this file.

#include "Engine/Logging/RenderDoc.h"
 
#include <iostream>
#include <vulkan/vulkan_core.h>
 
#ifdef RENDERDOC_ENABLED
#include <renderdoc_app.h>
#include <GLFW/glfw3native.h>
#include <iostream>
#ifdef WIN32
#include <windows.h>
#endif
#endif
 
RenderDoc& RenderDoc::get() {
    static RenderDoc instance;
    return instance;
}
 
bool RenderDoc::init() {
#ifdef RENDERDOC_ENABLED
    if (m_available) return true;
 
    // Check if RenderDoc is injected
    if (HMODULE mod = GetModuleHandleA("renderdoc.dll")) {
        pRENDERDOC_GetAPI getAPI = (pRENDERDOC_GetAPI)GetProcAddress(mod, "RENDERDOC_GetAPI");
 
        if (getAPI) {
            int ret = getAPI(eRENDERDOC_API_Version_1_6_0, (void**)&m_api);
            if (ret == 1) {
                m_available = true;
                std::cout << "RenderDoc API 1.6.0 connected\n";
            } else {
                ret = getAPI(eRENDERDOC_API_Version_1_1_2, (void**)&m_api);
                if (ret == 1) {
                    m_available = true;
                    std::cout << "RenderDoc API 1.1.2 connected\n";
                } else {
                    std::cout << "RenderDoc API not supported (tried 1.6.0 and 1.1.2)\n";
                    return false;
                }
            }
 
            m_api->SetCaptureOptionU32(eRENDERDOC_Option_AllowVSync, 0);
            m_api->SetCaptureOptionU32(eRENDERDOC_Option_AllowFullscreen, 0);
            m_api->SetCaptureOptionU32(eRENDERDOC_Option_APIValidation, 0);
            m_api->SetCaptureOptionU32(eRENDERDOC_Option_CaptureCallstacks, 1);
            m_api->SetCaptureOptionU32(eRENDERDOC_Option_HookIntoChildren, 1);
 
            return true;
        }
    }
 
    return false;
#else
    return false;
#endif
}
 
void RenderDoc::startCapture(VkDevice device) const {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        m_api->StartFrameCapture(nullptr, nullptr);
    }
#endif
}
 
void RenderDoc::endCapture(VkDevice device) const {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        uint32_t result = m_api->EndFrameCapture(nullptr, nullptr);
        std::cout << "RenderDoc end frame capture result: " << result << std::endl;
        if (result) {
            std::cout << "Frame captured successfully\n";
        }
    }
#endif
}
 
void RenderDoc::triggerCapture() {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        std::cout << "RenderDoc: Triggering capture...\n";
        m_api->TriggerCapture();
        std::cout << "RenderDoc: Trigger capture called successfully\n";
    } else {
        std::cout << "RenderDoc: API not available for trigger\n";
    }
#endif
}
 
bool RenderDoc::isCapturing() const {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        bool capturing = m_api->IsFrameCapturing() == 1;
        if (capturing) {
            std::cout << "RenderDoc: Frame is currently capturing\n";
        }
        return capturing;
    }
#endif
    return false;
}
 
bool RenderDoc::isConnected() const {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        return m_api->IsTargetControlConnected() == 1;
    }
#endif
    return false;
}
 
void RenderDoc::setCaptureTitle(const std::string& title) {
#ifdef RENDERDOC_ENABLED
    if (m_api && isCapturing()) {
        m_api->SetCaptureTitle(title.c_str());
    }
#endif
}
 
void RenderDoc::setCapturePath(const std::string& pathTemplate) {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        m_api->SetCaptureFilePathTemplate(pathTemplate.c_str());
    }
#endif
}
 
void RenderDoc::triggerMultiFrameCapture(uint32_t numFrames) {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        m_api->TriggerMultiFrameCapture(numFrames);
    }
#endif
}
 
void RenderDoc::printStatus() const {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        std::cout << "RenderDoc Status:\n";
        std::cout << "  - API Available: Yes\n";
        std::cout << "  - Currently Capturing: " << (isCapturing() ? "Yes" : "No") << "\n";
        std::cout << "  - UI Connected: " << (isConnected() ? "Yes" : "No") << "\n";
        std::cout << "  - Total Captures: " << getNumCaptures() << "\n";
    } else {
        std::cout << "RenderDoc Status: API not available\n";
    }
#else
    std::cout << "RenderDoc Status: Not compiled in\n";
#endif
}
 
uint32_t RenderDoc::getNumCaptures() const {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        return m_api->GetNumCaptures();
    }
#endif
    return 0;
}
 
void RenderDoc::launchUI() {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        m_api->LaunchReplayUI(1, nullptr);
    }
#endif
}
 
void RenderDoc::showUI() {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        m_api->ShowReplayUI();
    }
#endif
}
 
void RenderDoc::enableCallstacks(bool enable) {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        m_api->SetCaptureOptionU32(eRENDERDOC_Option_CaptureCallstacks, enable ? 1 : 0);
    }
#endif
}
 
void RenderDoc::enableAPIValidation(bool enable) {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        m_api->SetCaptureOptionU32(eRENDERDOC_Option_APIValidation, enable ? 1 : 0);
    }
#endif
}
 
void RenderDoc::enableOverlay(bool enable) {
#ifdef RENDERDOC_ENABLED
    if (m_api) {
        uint32_t mask = enable ? eRENDERDOC_Overlay_Default : eRENDERDOC_Overlay_None;
        m_api->MaskOverlayBits(~0U, mask);
    }
#endif
}