Source Valorant Agent Icon ESP — Dynamic Texture Fetching via K2

[byte_corvus]

If you are still bloating your internal builds with massive headers full of raw icon bytes like it's a decade ago, you're doing it wrong. Most Valorant pastes suffer from unnecessary memory overhead because people are too lazy to interface with the engine.

The Logic — Native Texture Hooking
Instead of storing static images, you can leverage Unreal Engine's own functions. By calling GetCharacterIcon on the ShooterCharacter object via ProcessEvent, the game returns the UObject pointer for the specific agent's texture. From there, you just pass it to K2_DrawTexture and let the engine handle the heavy lifting for your ESP.

You cant view this link please login.

Implementation: Fetching the UObject
You will need your K2 offsets and a working find_object implementation. This snippet handles the ProcessEvent call to grab the current pawn's agent icon:

uintptr_t TryGetCharacterIconUObject(uintptr_t shooterPawn)
{
    if (!shooterPawn) return 0;

    static uintptr_t g_GetCharacterIconFn = 0;
    if (!g_GetCharacterIconFn)
        g_GetCharacterIconFn = uobject::find_object(L"ShooterGame.ShooterCharacter.GetCharacterIcon");

    if (!g_GetCharacterIconFn) return 0;

    alignas(16) unsigned char paramBlob[64]{};
    std::memset(paramBlob, 0, sizeof(paramBlob));

    reinterpret_cast<UObject*>(shooterPawn)->process_event(g_GetCharacterIconFn, paramBlob);
    const uintptr_t tex = *reinterpret_cast<uintptr_t*>(paramBlob);

    return tex;
}

Rendering via K2 Canvas
Once you have the texture pointer, drawing it onto the canvas is straightforward. This method puts the icon right above the player's head or alongside the box, depending on your screen coordinates.

bool DrawOnCanvas(void* canvas, uintptr_t textureUObject, float rootScreenX, float rootScreenY)
{
    if (!canvas || !textureUObject) return false;

    const FLinearColor white{ 1.f, 1.f, 1.f, 1.f };
    const FVector2D pos{ rootScreenX - 10.f, rootScreenY + 28.f };
   
    // Size 20x20 is usually enough for a clean look
    const bool ok = CanvasDraw::K2_DrawTexture(canvas, reinterpret_cast<void*>(textureUObject), pos, FVector2D{ 20.f, 20.f },
        FVector2D{ 0.f, 0.f }, FVector2D{ 1.f, 1.f }, white, EBlendMode::Opaque, 0.f, FVector2D{ 0.5f, 0.5f });

    return ok;
}

Technical Considerations

1. Performance — Calling ProcessEvent every frame per player can be expensive. Cache the icon textures or use a throttled logger if you're debugging failures.
2. Vanguard — While calling engine functions is standard for internals, ensure your ProcessEvent hook isn't flagged or using a known-detected bridge.
3. Offsets — You need a clean way to resolve K2_DrawTexture and ProcessEvent. If you're using a generic SDK, they should already be there.
4. Blend Modes — If you want transparency, experiment with EBlendMode::Masked or Translucent instead of Opaque.

Spoiler: Troubleshooting Logs

If the texture returns NULL, it's usually a timing issue where the pawn isn't fully initialized or your find_object call failed. In Valorant, some UI elements aren't ready immediately upon pawn creation. Add a small validation check for the vtable before trying to draw to avoid unexpected crashes during agent selection.

Has anyone tried adapting this for ability icons or is everyone still hardcoding their assets?