Source Strayed VR FullBright & Tracker — Internal MinHook Base

[byte_corvus]

Found someone struggling with a basic internal for Strayed VR. The logic is there, but the execution has some classic rookie mistakes that you'll need to clean up if you want a working binary. We're looking at a Unity-based VR survival title (think Rust in VR), so lighting manipulation and player tracking are the bread and butter here.

The Technical Breakdown
The source uses MinHook to hijack Unity's lighting system and local player position updates. It's aiming for a FullBright setup by overriding ambient colors and sun intensity, plus a tracer for player positions.

Core Features Involved:

1. FullBright: Hooks into AmbientColor, SunIntensity, and FogColor.
2. Player Tracker: Hooks ClientSend_PlayerLocalPositions to dump head and hand coordinates to the console.
3. Dynamic Lighting Override: Attempts to force-disable shadows/dynamic adjustments.

#include <iostream>
#include <Windows.h>
#include "MinHook.h"
#include <random>
#include <thread>
#include <chrono>
 
typedef void(__cdecl* SetLightingColor_t)(uintptr_t, float, float, float);
typedef void(__cdecl* SetLightingIntensity_t)(uintptr_t, float);
typedef void(__cdecl* SetFogColor_t)(uintptr_t, float, float, float);
typedef void(__cdecl* SetDynamicLighting_t)(uintptr_t, bool);
 
SetLightingColor_t OriginalSetLightingColor = nullptr;
SetLightingIntensity_t OriginalSetLightingIntensity = nullptr;
SetFogColor_t OriginalSetFogColor = nullptr;
SetDynamicLighting_t OriginalSetDynamicLighting = nullptr;
 
uintptr_t gameBaseAddress = 0x7FF71DEA0000;
 
uintptr_t AmbientColorOffset = 0x0000000000822630;
uintptr_t DirectionalColorOffset = 0x0000000000822650;
uintptr_t FogColorOffset = 0x0000000000822670;
uintptr_t SunIntensityOffset = 0x00000000008226D0;
uintptr_t MoonIntensityOffset = 0x00000000008226F0;
 
float GetRandomFloat(float min, float max) {
    static std::random_device rd;
    static std::mt19937 gen(rd());
    std::uniform_real_distribution<> dis(min, max);
    return static_cast<float>(dis(gen));
}
 
typedef void(__fastcall* ClientSend_PlayerLocalPositions_t)(void* thisPtr, void* edx, void* headPosition,
    void* leftHandPosition, void* rightHandPosition, float locosphereY, const void* method);
 
ClientSend_PlayerLocalPositions_t Original_ClientSend_PlayerLocalPositions = nullptr;
 
void __fastcall Hooked_ClientSend_PlayerLocalPositions(void* thisPtr, void* edx, void* headPosition,
    void* leftHandPosition, void* rightHandPosition, float locosphereY, const void* method) {
 
    std::cout << "[Tracer] Player positions: "
        << "Head (" << headPosition << "), "
        << "Left Hand (" << leftHandPosition << "), "
        << "Right Hand (" << rightHandPosition << "), "
        << "LocosphereY: " << locosphereY << std::endl;
 
    Original_ClientSend_PlayerLocalPositions(thisPtr, edx, headPosition, leftHandPosition, rightHandPosition, locosphereY, method);
}
 
void __cdecl HookedSetLightingColor(uintptr_t lightingPropertyAddress, float r, float g, float b) {
    float newR = GetRandomFloat(0.9f, 1.0f);
    float newG = GetRandomFloat(0.9f, 1.0f);
    float newB = GetRandomFloat(0.9f, 1.0f);
 
    std::cout << "[Tracer] Setting lighting color: "
        << "R: " << newR << ", G: " << newG << ", B: " << newB << std::endl;
 
    OriginalSetLightingColor(lightingPropertyAddress, newR, newG, newB);
}
 
void __cdecl HookedSetLightingIntensity(uintptr_t intensityAddress, float intensity) {
    float newIntensity = GetRandomFloat(200.0f, 200.0f);
 
    std::cout << "[Tracer] Setting lighting intensity: "
        << "New Intensity: " << newIntensity << std::endl;
 
    OriginalSetLightingIntensity(intensityAddress, newIntensity);
}
 
void __cdecl HookedSetFogColor(uintptr_t fogPropertyAddress, float r, float g, float b) {
    float newR = GetRandomFloat(0.9f, 1.0f);
    float newG = GetRandomFloat(0.9f, 1.0f);
    float newB = GetRandomFloat(0.9f, 1.0f);
 
    std::cout << "[Tracer] Setting fog color: "
        << "R: " << newR << ", G: " << newG << ", B: " << newB << std::endl;
 
    OriginalSetFogColor(fogPropertyAddress, newR, newG, newB);
}
 
void __cdecl HookedSetDynamicLighting(uintptr_t dynamicLightingPropertyAddress, bool enable) {
    bool newEnable = (rand() % 2 == 0);
 
    std::cout << "[Tracer] Setting dynamic lighting: "
        << (newEnable ? "Enabled" : "Disabled") << std::endl;
 
    OriginalSetDynamicLighting(dynamicLightingPropertyAddress, newEnable);
}
 
void SetFullBrightLighting() {
    HookedSetLightingColor(gameBaseAddress + AmbientColorOffset, 1.0f, 1.0f, 1.0f);
    HookedSetLightingColor(gameBaseAddress + DirectionalColorOffset, 1.0f, 1.0f, 1.0f);
    HookedSetLightingIntensity(gameBaseAddress + SunIntensityOffset, 1000.0f);
    HookedSetLightingIntensity(gameBaseAddress + MoonIntensityOffset, 100.0f);
    HookedSetFogColor(gameBaseAddress + FogColorOffset, 1.0f, 1.0f, 1.0f);
    HookedSetDynamicLighting(gameBaseAddress + 0x00000000008E6430, false);
}
 
void InitializeHooks() {
    std::this_thread::sleep_for(std::chrono::duration<long long, std::milli>(3000));
 
    if (MH_Initialize() != MH_OK) {
        std::cerr << "MinHook initialization failed!" << std::endl;
        return;
    }
 
    if (MH_CreateHook((LPVOID)(gameBaseAddress + AmbientColorOffset), (LPVOID)&HookedSetLightingColor, (LPVOID*)&OriginalSetLightingColor) != MH_OK ||
        MH_CreateHook((LPVOID)(gameBaseAddress + DirectionalColorOffset), (LPVOID)&HookedSetLightingColor, (LPVOID*)&OriginalSetLightingColor) != MH_OK ||
        MH_CreateHook((LPVOID)(gameBaseAddress + SunIntensityOffset), (LPVOID)&HookedSetLightingIntensity, (LPVOID*)&OriginalSetLightingIntensity) != MH_OK ||
        MH_CreateHook((LPVOID)(gameBaseAddress + MoonIntensityOffset), (LPVOID)&HookedSetLightingIntensity, (LPVOID*)&OriginalSetLightingIntensity) != MH_OK ||
        MH_CreateHook((LPVOID)(gameBaseAddress + FogColorOffset), (LPVOID)&HookedSetFogColor, (LPVOID*)&OriginalSetFogColor) != MH_OK ||
        MH_CreateHook((LPVOID)(gameBaseAddress + 0x00000000008E6430), (LPVOID)&HookedSetDynamicLighting, (LPVOID*)&OriginalSetDynamicLighting) != MH_OK) {
        std::cerr << "Hook creation failed!" << std::endl;
        return;
    }
 
    uintptr_t ClientSend_PlayerLocalPositionsAddress = gameBaseAddress + 0x0000000000823000;
    if (MH_CreateHook((LPVOID)(ClientSend_PlayerLocalPositionsAddress), (LPVOID)&Hooked_ClientSend_PlayerLocalPositions, (LPVOID*)&Original_ClientSend_PlayerLocalPositions) != MH_OK) {
        std::cerr << "Failed to hook ClientSend_PlayerLocalPositions!" << std::endl;
        return;
    }
 
    if (MH_EnableHook(MH_ALL_HOOKS) != MH_OK) {
        std::cerr << "Failed to enable hooks!" << std::endl;
        return;
    }
}
 
int main() {
    std::cout << "Initializing hooks and setting full bright lighting..." << std::endl;
 
    InitializeHooks();
    SetFullBrightLighting();
 
    std::cout << "Full bright lighting applied!" << std::endl;
 
    std::this_thread::sleep_for(std::chrono::duration<long long, std::milli>(10000));
 
    return 0;
}

Spoiler: Technical Bottlenecks & Fixes

1. Hardcoded Base Address: The source uses 0x7FF71DEA0000. This is a death sentence for any DLL. You need to use GetModuleHandle(NULL) to grab the base dynamically, otherwise, the offsets will point to nowhere as soon as ASLR kicks in.

2. Calling Convention Mix-up: It's mixing __cdecl and __fastcall. Unity's Il2Cpp or Mono methods usually follow specific conventions depending on the target architecture. Verify if these are actual engine exports or internal methods.

3. Offset Drift: VR games update their Unity versions frequently. If the features aren't 'working' but the DLL injects, your offsets are almost certainly dead. Dump the game with Il2CppDumper or use a debugger to verify the functions still live at these locations.

Safety & Implementation
If you're going to use this, stop relying on hardcoded addresses. Write a proper pattern scanner or at least resolve the base at runtime. Since it's a VR title, be careful with the locosphereY values—messing with those can lead to some nasty desyncs or instant kicks if the server-side sanity checks are actually enabled.

Take the base, fix the module handling, and let's see if anyone has fresh offsets for the latest build.