借助全新的游戏内推理 SDK，将 NVIDIA ACE AI 角色引入游戏

nvigi::Preferences preferences{};
preferences.logLevel = nvigi::LogLevel::eVerbose; // Enable verbose logging
preferences.utf8PathsToPlugins = {"path/to/plugins"}; // Set plugin path
preferences.utf8PathToLogsAndData = "path/to/logs";    // Define log path

if (nvigiInit(preferences, nullptr, nvigi::kSDKVersion) != nvigi::kResultOk) {
    std::cerr << "Failed to initialize NVIGI." << std::endl;
}

// Load GPT plugin interface
nvigi::IGeneralPurposeTransformer* gpt = nullptr;
nvigiGetInterfaceDynamic(nvigi::plugin::gpt::ggml::cuda::kId, &gpt, ptr_nvigiLoadInterface);

// Configure model parameters
nvigi::CommonCreationParameters common{};
common.utf8PathToModels = "path/to/models";
common.numThreads = 8;                    // Number of CPU threads
common.vramBudgetMB = vram;               // VRAM allocation in MB
common.modelGUID = "{YOUR_MODEL_GUID}";   // Model GUID

// Create GPT instance
nvigi::InferenceInstance* gptInstance = nullptr;
if (gpt->createInstance(common, &gptInstance) != nvigi::kResultOk || !gptInstance) {
    std::cerr << "Failed to create GPT instance." << std::endl;
}

// Use GPT instance for inference

// Define NPC role in a system prompt
std::string npcPrompt = "You are a helpful NPC named TJ in a fantasy game.";
nvigi::CpuData systemPromptData(npcPrompt.length() + 1, npcPrompt.c_str());
nvigi::InferenceDataText systemPromptSlot(systemPromptData);

// Set runtime parameters
nvigi::GPTRuntimeParameters runtime{};
runtime.tokensToPredict = 200;  // Limit token prediction to 200 tokens
runtime.interactive = true;     // Enable multi-turn conversations
std::vector<nvigi::InferenceDataSlot> slots = {
    {nvigi::kGPTDataSlotSystem, &systemPromptSlot}
};

// Inference context
nvigi::InferenceExecutionContext gptExecCtx{};
gptExecCtx.instance = gptInstance;
gptExecCtx.runtimeParameters = runtime;
gptExecCtx.inputs = slots.data();

std::string userInput = "What’s your name?"; // example user input
nvigi::CpuData userInputData(userInput.length() + 1, userInput.c_str());
nvigi::InferenceDataText userInputSlot(userInputData);

slots = {{nvigi::kGPTDataSlotUser, &userInputSlot}};
gptExecCtx.inputs = slots.data();

if (gptExecCtx.instance->evaluate(&gptExecCtx) == nvigi::kResultOk) {
    std::cout << "Inference completed successfully!" << std::endl;
}

// Enable Compute-in-Graphics (CIG)
nvigi::IHWICuda* icig = nullptr;
if (nvigiGetInterface(nvigi::plugin::hwi::cuda::kId, &icig) != nvigi::kResultOk || !icig) {
    std::cerr << "Failed to load CIG interface." << std::endl;
    return;
}

// Set up D3D12 parameters
nvigi::D3D12Parameters d3d12Params{};
d3d12Params.device = myD3D12Device;            // D3D12 device used for rendering
d3d12Params.queue = myD3D12CommandQueue;      // Graphics command queue

// Activate GPU scheduling for both inference and rendering
if (icig->enableComputeInGraphics(d3d12Params) != nvigi::kResultOk) {
    std::cerr << "Failed to enable Compute-in-Graphics." << std::endl;
    return;
}

std::cout << "Compute-in-Graphics enabled successfully." << std::endl;

// UE5-specific code to retrieve D3D12 resources
#include "ID3D12DynamicRHI.h"

ID3D12DynamicRHI* RHI = nullptr;
if (GDynamicRHI && GDynamicRHI->GetInterfaceType() == ERHIInterfaceType::D3D12)
{
    RHI = static_cast<ID3D12DynamicRHI*>(GDynamicRHI);
}

ID3D12CommandQueue* CmdQ = nullptr;
ID3D12Device* D3D12Device = nullptr;

if (RHI) {
    CmdQ = RHI->RHIGetCommandQueue();  // Get graphics command queue
    int DeviceIndex = 0;
    D3D12Device = RHI->RHIGetDevice(DeviceIndex);  // Get D3D12 device
}

// Configure D3D12 parameters for IGI
nvigi::D3D12Parameters d3d12Params{};
d3d12Params.device = D3D12Device;
d3d12Params.queue = CmdQ;

// Pass the parameters to IGI instances
nvigi::CommonCreationParameters commonParams{};
commonParams.chain(d3d12Params);

// Example: Creating an ASR instance with CIG
nvigi::ASRCreationParameters asrParams{};
asrParams.common = &commonParams;

nvigi::InferenceInstance* asrInstance = nullptr;
iasr->createInstance(asrParams, &asrInstance);

// Configure runtime parameters for GPT
nvigi::GPTRuntimeParameters runtime{};
runtime.tokensToPredict = 200;  // Predict up to 200 tokens
runtime.interactive = true;     // Enable interactive mode

// Set up inference context
nvigi::InferenceExecutionContext gptExecCtx{};
gptExecCtx.instance = gptInstance;   // Use the GPT instance created earlier
gptExecCtx.runtimeParameters = runtime;

gptExecCtx.callback = [](const nvigi::InferenceExecutionContext* execCtx, nvigi::InferenceExecutionState state, void* userData) {
    if (state == nvigi::kInferenceExecutionStateDone && execCtx->outputs){
        const nvigi::InferenceDataText* responseText = nullptr;
        execCtx->outputs->findAndValidateSlot(nvigi::kGPTDataSlotResponse, &responseText);
        if (responseText) {
            std::cout << "NPC Response: " << responseText->getUtf8Text() << std::endl;
        }
    }
    return state;
};

// Set up conversation context
std::string npcPrompt = "You are a helpful NPC in a fantasy game. Respond thoughtfully to player questions.";

nvigi::CpuData systemPromptData(npcPrompt.length() + 1, npcPrompt.c_str());
nvigi::InferenceDataText systemPromptSlot(systemPromptData);

std::vector<nvigi::InferenceDataSlot> slots = {
    {nvigi::kGPTDataSlotSystem, &systemPromptSlot}  // Set the system prompt
};

gptExecCtx.inputs = slots.data();
gptExecCtx.numInputs = slots.size();

// Execute to initialize conversation context
if (gptExecCtx.instance->evaluate(&gptExecCtx) != nvigi::kResultOk) {
    std::cerr << "Failed to initialize conversation context." << std::endl;
    return;
}