37
"----------------------------------------------"
FFFF80
1
35
"- Outriders Camera for Steam"
FFFF80
1
36
"- Antic Owl"
FFFF80
1
4027
"- See Table Extra for info"
FFFF80
1
34
"----------------------------------------------"
FFFF80
1
8397
"Auto Attach To Game"
0000FF
Auto Assembler Script
{$lua}
[ENABLE]
local processName = "OUTRIDERS-Win64-Shipping.exe"
local function onTimer_Tick(timer)
if readInteger(processName) == nil then
local processId = getProcessIDFromProcessName(processName)
if processId and processId ~= getOpenedProcessID() then
openProcess(processId)
end
end
end
local autoAttachTimer = createTimer(getMainForm(), true)
autoAttachTimer.Interval = 1000
autoAttachTimer.OnTimer = onTimer_Tick
[DISABLE]
26254
"Camera - Leave On!"
Auto Assembler Script
[ENABLE]
aobscanmodule(Camera,OUTRIDERS-Win64-Shipping.exe,F2 0F 10 02 48 8B D9 F2 0F 11 01 48) // should be unique
alloc(newmem,$1000,Camera)
label(code)
label(return)
label(pCamera)
newmem:
mov [pCamera], rdx
code:
movsd xmm0,[rdx]
mov rbx,rcx
jmp return
pCamera:
dq 0
Camera:
jmp newmem
nop 2
return:
registersymbol(Camera)
registersymbol(pCamera)
[DISABLE]
Camera:
db F2 0F 10 02 48 8B D9
unregistersymbol(*)
dealloc(*)
Toggle Activation
34
0
26255
"X"
0
Float
[pCamera]
26262
"Y"
0
Float
[pCamera]+4
26261
"Z"
0
Float
[pCamera]+8
26260
"Pitch"
0
Float
[pCamera]+C
26259
"Yaw"
0
Float
[pCamera]+10
26258
"Roll"
0
Float
[pCamera]+14
26257
"FOV"
0
Float
[pCamera]+18
26256
"Detach Camera"
Auto Assembler Script
//-- Speed modifier for camera movement
globalalloc(speedModifier,8)
speedModifier:
dd (float)7
[ENABLE]
OUTRIDERS-Win64-Shipping.exe+31996D4:
db 90 90 90 90
OUTRIDERS-Win64-Shipping.exe+31996E0:
db 90 90 90
OUTRIDERS-Win64-Shipping.exe+31997A5:
db 90 90 90 90 90
OUTRIDERS-Win64-Shipping.exe+319980F:
db 90 90 90
OUTRIDERS-Win64-Shipping.exe+14754DE:
db 90 90 90
{$lua}
------------------------------------------------------------
-- Keyboard + universal CE XInput controller support
--
-- LS = Move / strafe
-- RS = Yaw / pitch
-- LT / RT = Down / Up
-- LB / RB = Roll
-- D-Pad = FOV - / +
-- B = Reset roll
-- X = Slow
-- Y = Fast
------------------------------------------------------------
local PAD = {
deadzone = 0.18,
triggerDeadzone = 0.08,
moveSpeed = 7.0,
rotateSpeed = 1.15,
rollSpeed = 1.15,
fovSpeed = 0.55,
slowFactor = 0.25,
fastFactor = 4.0
}
local function getCamBase()
local p = getAddressSafe('pCamera')
if not p then return nil end
local cam = readPointer(p)
if not cam or cam == 0 then return nil end
return cam
end
local function normalizeStick(v)
if v == nil then return 0 end
if math.abs(v) > 1.0 then
if v < 0 then v = v / 32768.0 else v = v / 32767.0 end
end
if math.abs(v) <= PAD.deadzone then return 0 end
local sign = v < 0 and -1 or 1
return sign * ((math.abs(v) - PAD.deadzone) / (1.0 - PAD.deadzone))
end
local function normalizeTrigger(v)
if v == nil then return 0 end
if v > 1.0 then v = v / 255.0 end
if v <= PAD.triggerDeadzone then return 0 end
return (v - PAD.triggerDeadzone) / (1.0 - PAD.triggerDeadzone)
end
local function pressed(s, key)
return s and s[key] == true
end
local function moveCamera(cam, forward, right, up, speed)
local x = readFloat(cam + 0x00)
local y = readFloat(cam + 0x04)
local z = readFloat(cam + 0x08)
local pitchDeg = readFloat(cam + 0x0C)
local yawDeg = readFloat(cam + 0x10)
if not x or not y or not z or not pitchDeg or not yawDeg then return end
local pitch = math.rad(pitchDeg)
local yaw = math.rad(yawDeg)
local cosy, siny = math.cos(yaw), math.sin(yaw)
local sinp = math.sin(pitch)
-- Keep the exact movement convention already used by this table.
x = x + (cosy * forward * speed)
y = y + (siny * forward * speed)
z = z + (sinp * forward * speed)
local sideYaw = yaw - math.rad(90)
x = x - (math.cos(sideYaw) * right * speed)
y = y - (math.sin(sideYaw) * right * speed)
z = z + (up * speed * 0.5)
writeFloat(cam + 0x00, x)
writeFloat(cam + 0x04, y)
writeFloat(cam + 0x08, z)
end
local function checkKeys()
if getOpenedProcessID() ~= getForegroundProcess() then return end
-- IGCSDOF render-session input lock:
-- Ignore CE freecam keyboard/controller input only.
-- Keys are NOT blocked at OS level, so ReShade still receives the numpad.
if IGCSDOF_SESSION_ACTIVE == true then return end
local cam = getCamBase()
if not cam then return end
local speed = readFloat('speedModifier') or 7.0
local campitch = readFloat(cam + 0x0C)
local camyaw = readFloat(cam + 0x10)
local camroll = readFloat(cam + 0x14)
local camFOV = readFloat(cam + 0x18)
if not campitch or not camyaw or not camroll or not camFOV then return end
----------------------------------------------------------
-- KEYBOARD (original behavior preserved)
----------------------------------------------------------
local pitch = math.rad(campitch)
local yaw = math.rad(camyaw)
local siny = math.sin(yaw)
local cosy = math.cos(yaw)
local sinp = math.sin(pitch)
local camx = readFloat(cam + 0x00)
local camy = readFloat(cam + 0x04)
local camz = readFloat(cam + 0x08)
-- Pitch
if isKeyPressed(VK_UP) then
writeFloat(cam + 0x0C, campitch + speed)
end
if isKeyPressed(VK_DOWN) then
writeFloat(cam + 0x0C, campitch - speed)
end
-- Yaw
if isKeyPressed(VK_LEFT) then
writeFloat(cam + 0x10, camyaw - speed)
end
if isKeyPressed(VK_RIGHT) then
writeFloat(cam + 0x10, camyaw + speed)
end
-- FOV
if isKeyPressed(VK_ADD) then
writeFloat(cam + 0x18, camFOV - speed * 0.5)
end
if isKeyPressed(VK_SUBTRACT) then
writeFloat(cam + 0x18, camFOV + speed * 0.5)
end
-- Forward
if isKeyPressed(VK_NUMPAD8) then
writeFloat(cam + 0x00, camx + (cosy * speed))
writeFloat(cam + 0x04, camy + (siny * speed))
writeFloat(cam + 0x08, camz + (sinp * speed))
end
-- Left
if isKeyPressed(VK_NUMPAD4) then
writeFloat(cam + 0x00, camx + (math.cos(yaw - math.rad(90)) * speed))
writeFloat(cam + 0x04, camy + (math.sin(yaw - math.rad(90)) * speed))
end
-- Back
if isKeyPressed(VK_NUMPAD5) then
writeFloat(cam + 0x00, camx - (cosy * speed))
writeFloat(cam + 0x04, camy - (siny * speed))
writeFloat(cam + 0x08, camz - (sinp * speed))
end
-- Right
if isKeyPressed(VK_NUMPAD6) then
writeFloat(cam + 0x00, camx - (math.cos(yaw - math.rad(90)) * speed))
writeFloat(cam + 0x04, camy - (math.sin(yaw - math.rad(90)) * speed))
end
-- Forward/Right
if isKeyPressed(VK_NUMPAD8) and isKeyPressed(VK_NUMPAD6) then
writeFloat(cam + 0x00, camx + (math.cos(yaw + math.rad(45)) * speed))
writeFloat(cam + 0x04, camy + (math.sin(yaw + math.rad(45)) * speed))
writeFloat(cam + 0x08, camz + (sinp * speed))
end
-- Forward/Left
if isKeyPressed(VK_NUMPAD8) and isKeyPressed(VK_NUMPAD4) then
writeFloat(cam + 0x00, camx + (math.cos(yaw - math.rad(45)) * speed))
writeFloat(cam + 0x04, camy + (math.sin(yaw - math.rad(45)) * speed))
writeFloat(cam + 0x08, camz + (sinp * speed))
end
-- Back/Left
if isKeyPressed(VK_NUMPAD5) and isKeyPressed(VK_NUMPAD4) then
writeFloat(cam + 0x00, camx - (math.cos(yaw + math.rad(45)) * speed))
writeFloat(cam + 0x04, camy - (math.sin(yaw + math.rad(45)) * speed))
writeFloat(cam + 0x08, camz - (sinp * speed))
end
-- Back/Right
if isKeyPressed(VK_NUMPAD5) and isKeyPressed(VK_NUMPAD6) then
writeFloat(cam + 0x00, camx - (math.cos(yaw - math.rad(45)) * speed))
writeFloat(cam + 0x04, camy - (math.sin(yaw - math.rad(45)) * speed))
writeFloat(cam + 0x08, camz - (sinp * speed))
end
-- Up
if isKeyPressed(VK_NUMPAD9) then
writeFloat(cam + 0x08, camz + (speed * 0.5))
end
-- Down
if isKeyPressed(VK_NUMPAD7) then
writeFloat(cam + 0x08, camz - (speed * 0.5))
end
-- Roll
if isKeyPressed(VK_NUMPAD1) then
writeFloat(cam + 0x14, camroll - (speed * 0.5))
end
if isKeyPressed(VK_NUMPAD3) then
writeFloat(cam + 0x14, camroll + (speed * 0.5))
end
----------------------------------------------------------
-- GAMEPAD
----------------------------------------------------------
local ok, state = pcall(getXBox360ControllerState, 0)
if (not ok) or (not state) then
ok, state = pcall(getXBox360ControllerState)
end
if ok and state then
local lx = normalizeStick(state.ThumbLeftX)
local ly = normalizeStick(state.ThumbLeftY)
local rx = normalizeStick(state.ThumbRightX)
local ry = normalizeStick(state.ThumbRightY)
local lt = normalizeTrigger(state.LeftTrigger)
local rt = normalizeTrigger(state.RightTrigger)
local factor = 1.0
if pressed(state, 'GAMEPAD_X') then factor = PAD.slowFactor end
if pressed(state, 'GAMEPAD_Y') then factor = PAD.fastFactor end
local moveSpeed = PAD.moveSpeed * factor
local rotateSpeed = PAD.rotateSpeed * factor
if lx ~= 0 or ly ~= 0 or lt ~= 0 or rt ~= 0 then
moveCamera(cam, ly, lx, rt - lt, moveSpeed)
end
if rx ~= 0 then
writeFloat(cam + 0x10, (readFloat(cam + 0x10) or camyaw) + rx * rotateSpeed)
end
if ry ~= 0 then
writeFloat(cam + 0x0C, (readFloat(cam + 0x0C) or campitch) + ry * rotateSpeed)
end
local roll = readFloat(cam + 0x14) or camroll
if pressed(state, 'GAMEPAD_LEFT_SHOULDER') then
roll = roll - PAD.rollSpeed * factor
end
if pressed(state, 'GAMEPAD_RIGHT_SHOULDER') then
roll = roll + PAD.rollSpeed * factor
end
if pressed(state, 'GAMEPAD_B') then
roll = 0.0
end
writeFloat(cam + 0x14, roll)
local fov = readFloat(cam + 0x18) or camFOV
if pressed(state, 'GAMEPAD_DPAD_UP') then
fov = fov - PAD.fovSpeed * factor
end
if pressed(state, 'GAMEPAD_DPAD_DOWN') then
fov = fov + PAD.fovSpeed * factor
end
writeFloat(cam + 0x18, fov)
end
----------------------------------------------------------
-- KEYBOARD SPEED MODIFIERS
----------------------------------------------------------
if isKeyPressed(VK_F) and isKeyPressed(VK_MENU) then
writeFloat('speedModifier', 500)
elseif isKeyPressed(VK_LCONTROL) then
if speed < 5000 then
writeFloat('speedModifier', speed + 2)
end
elseif isKeyPressed(VK_MENU) then
writeFloat('speedModifier', 0.5)
else
writeFloat('speedModifier', 7)
end
end
if OUTRIDERS_CAM_TIMER then
OUTRIDERS_CAM_TIMER.destroy()
OUTRIDERS_CAM_TIMER = nil
end
OUTRIDERS_CAM_TIMER = createTimer(nil, false)
OUTRIDERS_CAM_TIMER.Interval = 10
OUTRIDERS_CAM_TIMER.OnTimer = checkKeys
OUTRIDERS_CAM_TIMER.Enabled = true
{$asm}
[DISABLE]
OUTRIDERS-Win64-Shipping.exe+31996D4:
db F2 0F 11 0F
OUTRIDERS-Win64-Shipping.exe+31996E0:
db 89 47 08
OUTRIDERS-Win64-Shipping.exe+31997A5:
db F2 0F 11 47 0C
OUTRIDERS-Win64-Shipping.exe+319980F:
db 89 47 14
OUTRIDERS-Win64-Shipping.exe+14754DE:
db 89 46 18
{$lua}
if OUTRIDERS_CAM_TIMER then
OUTRIDERS_CAM_TIMER.destroy()
OUTRIDERS_CAM_TIMER = nil
end
{$asm}
Toggle Activation
45
0
26302
"Disable HUD"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
if hudTimer then
hudTimer.destroy()
hudTimer = nil
end
hudTimer = createTimer(nil)
hudTimer.Interval = 175
hudTimer.OnTimer = function(t)
t.destroy()
hudTimer = nil
local p = getAddressSafe("pHud")
if not p then return end
local base = readQword(p)
if not base or base == 0 then return end
writeBytes(base + 0x328, 0x01)
end
{$asm}
aobscanmodule(hud,OUTRIDERS-Win64-Shipping.exe,0F B6 97 28 03 00 00 48)
alloc(newmem,$1000,hud)
label(code)
label(return)
label(pHud)
newmem:
mov [pHud],rdi
code:
movzx edx,byte ptr [rdi+00000328]
jmp return
pHud:
dq 0
hud:
jmp newmem
nop 2
return:
registersymbol(hud)
registersymbol(pHud)
[DISABLE]
{$lua}
if syntaxcheck then return end
if hudTimer then
hudTimer.destroy()
hudTimer = nil
end
local p = getAddressSafe("pHud")
if p then
local base = readQword(p)
if base and base ~= 0 then
writeBytes(base + 0x328, 0x02)
end
end
{$asm}
hud:
db 0F B6 97 28 03 00 00
unregistersymbol(hud)
unregistersymbol(pHud)
dealloc(newmem)
Toggle Activation
46
0
26303
"--------------------------------------------------------------------------------------------"
FFFF80
1
26267
"Time Stop"
Auto Assembler Script
[ENABLE]
OUTRIDERS-Win64-Shipping.exe+3418061:
db B0 01
[DISABLE]
OUTRIDERS-Win64-Shipping.exe+3418061:
db 32 C0
Toggle Activation
96
0
26263
"Slomo"
Auto Assembler Script
[ENABLE]
aobscanmodule(slom,OUTRIDERS-Win64-Shipping.exe,F3 0F 59 81 E8 03 00 00) // should be unique
alloc(newmem,$1000,slom)
label(code)
label(return)
label(pSlom)
newmem:
mov [pSlom], rcx
code:
mulss xmm0,[rcx+000003E8]
jmp return
pSlom:
dq 0
slom:
jmp newmem
nop 3
return:
registersymbol(slom)
registersymbol(pSlom)
[DISABLE]
slom:
db F3 0F 59 81 E8 03 00 00
unregistersymbol(*)
dealloc(*)
Toggle Activation
33
0
26264
"Slomo Value"
0
Float
[pSlom]+3e8
Set Value
116
0.15
0
Set Value
117
0.3
1
Set Value
118
1.0
2
26304
"--------------------------------------------------------------------------------------------"
FFFF80
1
26300
"IGCS Support"
Auto Assembler Script
{$lua}
[ENABLE]
if syntaxcheck then return end
------------------------------------------------------------
-- IGCSDOF UNIVERSAL RAW PROVIDER v4
--
-- Generic Cheat Engine -> IGCSDOF Universal Bridge
--
-- NO GAME NAME.
-- NO CAMERA-BASIS MATH.
--
-- Normally you only change:
--
-- 1. engine
-- 2. cameraSymbol
-- 3. position offsets
-- 4. rotation offsets
-- 5. FOV offset
-- 6. optional cameraLockSymbol
-- 7. optional writer instructions
--
-- Supported engine tags:
--
-- UE2.5
-- UE3
-- UE4
-- idTech7
-- Northlight
--
-- Engine-specific camera math stays in the bridge.
------------------------------------------------------------
------------------------------------------------------------
-- USER CONFIGURATION
------------------------------------------------------------
local CONFIG = {
engine = "UE4",
bases = {
position = "pCamera",
rotation = "pCamera",
fov = "pCamera"
},
position = {
x = 0x00,
y = 0x04,
z = 0x08
},
rotation = {
pitch = 0x0C,
yaw = 0x10,
roll = 0x14
},
fov = {
offset = 0x18
},
cameraLockSymbol = "",
writers = {
},
restoreHoldMs = 250,
cameraIntervalMs = 16
}
------------------------------------------------------------
-- END USER CONFIGURATION
--
-- STOP EDITING HERE.
-- Everything below this line is universal provider core.
------------------------------------------------------------
local CAMERA_PIPE_NAME =
"IGCSDOF_ProviderToBridge_v1"
local COMMAND_PIPE_NAME =
"IGCSDOF_BridgeToProvider_v1"
local RECONNECT_DELAY_MS = 1000
------------------------------------------------------------
-- ENGINE PROFILE
--
-- IMPORTANT:
-- This section defines ONLY provider-side memory behavior.
-- It does not define camera basis math.
------------------------------------------------------------
local ENGINE_PROFILE = {
["UE2.5"] = {
rotationType = "integer",
forcePointerLock = false,
forceWriterLock = false,
useRestoreHold = false
},
["UE3"] = {
rotationType = "integer",
forcePointerLock = false,
forceWriterLock = false,
useRestoreHold = false
},
["UE4"] = {
rotationType = "float",
forcePointerLock = false,
forceWriterLock = false,
useRestoreHold = false
},
["idTech7"] = {
rotationType = "float",
-- Validated behavior:
forcePointerLock = true,
forceWriterLock = true,
useRestoreHold = true
},
["Northlight"] = {
rotationType = "float",
forcePointerLock = false,
forceWriterLock = false,
useRestoreHold = false
}
}
local function getEngineProfile()
return
ENGINE_PROFILE[CONFIG.engine] or
ENGINE_PROFILE["UE4"]
end
local function usesIntegerRotator()
return
getEngineProfile().rotationType == "integer"
end
------------------------------------------------------------
-- GENERATION / STATE
------------------------------------------------------------
IGCSDOF_PROVIDER_GENERATION =
(IGCSDOF_PROVIDER_GENERATION or 0) + 1
-- Shared with the freecam input loop. This is only a logical CE input gate;
-- it does not consume or block Windows/ReShade keyboard input.
IGCSDOF_SESSION_ACTIVE = false
local myGeneration =
IGCSDOF_PROVIDER_GENERATION
IGCSDOF_PROVIDER_CONTEXTS =
IGCSDOF_PROVIDER_CONTEXTS or {}
local ctx = {
active = true,
cameraPipe = nil,
commandPipe = nil,
latestCameraLine = nil,
cameraSequence = 0,
sessionActive = false,
savedCamera = nil,
restorePending = false,
restoreCamera = nil,
restoreStart = 0,
writersLocked = false
}
IGCSDOF_PROVIDER_CONTEXTS[myGeneration] = ctx
local unpackFn =
table.unpack or unpack
local function isCurrent()
return
ctx.active and
IGCSDOF_PROVIDER_GENERATION == myGeneration
end
------------------------------------------------------------
-- HELPERS
------------------------------------------------------------
local function safeDestroy(pipe)
if pipe then
pcall(function()
pipe.destroy()
end)
end
end
local function safeWrite(pipe, line)
return pcall(function()
pipe.writeString(line .. "\n")
end)
end
local function splitLine(line)
local result = {}
for value in string.gmatch(line, "([^|]+)") do
result[#result + 1] = value
end
return result
end
local function roundInteger(value)
if value >= 0 then
return math.floor(value + 0.5)
end
return math.ceil(value - 0.5)
end
local function makeNops(count)
local result = {}
for i = 1, count do
result[i] = 0x90
end
return result
end
------------------------------------------------------------
-- CAMERA POINTER
------------------------------------------------------------
local function resolveBase(kind)
if not CONFIG.bases then
return nil
end
local name = CONFIG.bases[kind]
if not name or name == "" then
return nil
end
----------------------------------------------------------
-- 1. Existing Lua global variable containing an address
----------------------------------------------------------
local globalValue = rawget(_G, name)
if type(globalValue) == "number" and globalValue ~= 0 then
return globalValue
end
----------------------------------------------------------
-- 2. Existing Lua global function returning an address
----------------------------------------------------------
if type(globalValue) == "function" then
local ok, address =
pcall(globalValue)
if ok and
type(address) == "number" and
address ~= 0 then
return address
end
return nil
end
----------------------------------------------------------
-- 3. CE registered symbol containing a pointer
----------------------------------------------------------
local symbolAddress =
getAddressSafe(name)
if not symbolAddress then
return nil
end
local pointerValue =
readPointer(symbolAddress)
if not pointerValue or
pointerValue == 0 then
return nil
end
return pointerValue
end
------------------------------------------------------------
-- CAMERA POINTER LOCK
------------------------------------------------------------
local function setCameraPointerLock(locked)
if not CONFIG.cameraLockSymbol or
CONFIG.cameraLockSymbol == "" then
return
end
local address =
getAddressSafe(CONFIG.cameraLockSymbol)
if not address then
return
end
writeBytes(
address,
locked and 1 or 0
)
end
------------------------------------------------------------
-- RAW ROTATION READ / WRITE
------------------------------------------------------------
local function readRotation(address)
if usesIntegerRotator() then
return readInteger(address)
end
return readFloat(address)
end
local function writeRotation(address, value)
if usesIntegerRotator() then
writeInteger(
address,
roundInteger(value)
)
else
writeFloat(
address,
value
)
end
end
------------------------------------------------------------
-- CAMERA READ
------------------------------------------------------------
local function readCamera()
local posBase = resolveBase("position")
local rotBase = resolveBase("rotation")
local fovBase = resolveBase("fov")
if not posBase or not rotBase or not fovBase then
return nil
end
local camera = {
x = readFloat(
posBase + CONFIG.position.x
),
y = readFloat(
posBase + CONFIG.position.y
),
z = readFloat(
posBase + CONFIG.position.z
),
pitch = readRotation(
rotBase + CONFIG.rotation.pitch
),
yaw = readRotation(
rotBase + CONFIG.rotation.yaw
),
roll = readRotation(
rotBase + CONFIG.rotation.roll
),
fov = readFloat(
fovBase + CONFIG.fov.offset
)
}
if camera.x == nil or
camera.y == nil or
camera.z == nil or
camera.pitch == nil or
camera.yaw == nil or
camera.roll == nil or
camera.fov == nil then
return nil
end
return camera
end
------------------------------------------------------------
-- CAMERA WRITE
------------------------------------------------------------
local function cloneCamera(camera)
if not camera then
return nil
end
return {
x = camera.x,
y = camera.y,
z = camera.z,
pitch = camera.pitch,
yaw = camera.yaw,
roll = camera.roll,
fov = camera.fov
}
end
local function writeCamera(camera)
if not camera then
return false
end
local posBase = resolveBase("position")
local rotBase = resolveBase("rotation")
local fovBase = resolveBase("fov")
if not posBase or not rotBase or not fovBase then
return false
end
writeFloat(
posBase + CONFIG.position.x,
camera.x
)
writeFloat(
posBase + CONFIG.position.y,
camera.y
)
writeFloat(
posBase + CONFIG.position.z,
camera.z
)
writeRotation(
rotBase + CONFIG.rotation.pitch,
camera.pitch
)
writeRotation(
rotBase + CONFIG.rotation.yaw,
camera.yaw
)
writeRotation(
rotBase + CONFIG.rotation.roll,
camera.roll
)
writeFloat(
fovBase + CONFIG.fov.offset,
camera.fov
)
return true
end
------------------------------------------------------------
-- CAMERA WRITER LOCK
------------------------------------------------------------
local function enableWriterLock()
if ctx.writersLocked then
return
end
for _, writer in ipairs(CONFIG.writers or {}) do
local address =
getAddressSafe(writer.address)
if address and writer.bytes then
writeBytes(
address,
unpackFn(
makeNops(#writer.bytes)
)
)
end
end
ctx.writersLocked = true
end
local function disableWriterLock()
if not ctx.writersLocked then
return
end
for _, writer in ipairs(CONFIG.writers or {}) do
local address =
getAddressSafe(writer.address)
if address and writer.bytes then
writeBytes(
address,
unpackFn(writer.bytes)
)
end
end
ctx.writersLocked = false
end
------------------------------------------------------------
-- CAMERA_RAW MESSAGE
------------------------------------------------------------
local function makeCameraLine()
local camera =
readCamera()
if not camera then
return "CAMERA_INVALID"
end
local locked =
ctx.sessionActive or
ctx.restorePending
local rotationFormat =
usesIntegerRotator()
and "%d|%d|%d"
or "%.9f|%.9f|%.9f"
local format =
"CAMERA_RAW|1|1|%d|" ..
"%.9f|%.9f|%.9f|" ..
rotationFormat ..
"|%.9f"
return string.format(
format,
locked and 1 or 0,
camera.x,
camera.y,
camera.z,
camera.pitch,
camera.yaw,
camera.roll,
camera.fov
)
end
------------------------------------------------------------
-- ENGINE-SPECIFIC PROVIDER LIFECYCLE
------------------------------------------------------------
local function beginProviderLock()
if CONFIG.engine == "idTech7" then
setCameraPointerLock(true)
enableWriterLock()
end
end
local function releaseProviderLock()
if CONFIG.engine == "idTech7" then
disableWriterLock()
setCameraPointerLock(false)
end
end
------------------------------------------------------------
-- SESSION BEGIN
------------------------------------------------------------
local function startSession()
if ctx.sessionActive then
return
end
local camera =
readCamera()
if not camera then
return
end
ctx.savedCamera =
cloneCamera(camera)
beginProviderLock()
writeCamera(ctx.savedCamera)
ctx.sessionActive = true
IGCSDOF_SESSION_ACTIVE = true
ctx.latestCameraLine =
makeCameraLine()
ctx.cameraSequence =
ctx.cameraSequence + 1
end
------------------------------------------------------------
-- SESSION END
------------------------------------------------------------
local function finishRestore()
if ctx.restoreCamera then
writeCamera(ctx.restoreCamera)
end
releaseProviderLock()
ctx.savedCamera = nil
ctx.restoreCamera = nil
ctx.restorePending = false
ctx.restoreStart = 0
end
local function endSession()
local profile =
getEngineProfile()
if ctx.savedCamera then
ctx.restoreCamera =
cloneCamera(ctx.savedCamera)
writeCamera(ctx.restoreCamera)
end
ctx.sessionActive = false
IGCSDOF_SESSION_ACTIVE = false
if profile.useRestoreHold then
ctx.restorePending = true
ctx.restoreStart =
getTickCount()
else
ctx.restorePending = false
finishRestore()
end
end
local function processPendingRestore()
if not ctx.restorePending then
return
end
if ctx.restoreCamera then
writeCamera(ctx.restoreCamera)
end
if
getTickCount() - ctx.restoreStart
<
(CONFIG.restoreHoldMs or 250)
then
return
end
finishRestore()
end
------------------------------------------------------------
-- COMMANDS FROM BRIDGE
------------------------------------------------------------
local function setPositionRaw(x, y, z, fov)
local posBase = resolveBase("position")
if not posBase then
return
end
writeFloat(
posBase + CONFIG.position.x,
x
)
writeFloat(
posBase + CONFIG.position.y,
y
)
writeFloat(
posBase + CONFIG.position.z,
z
)
end
local function rotateYawRaw(delta)
local rotBase = resolveBase("rotation")
if not rotBase then
return
end
local address =
rotBase + CONFIG.rotation.yaw
local yaw =
readRotation(address) or 0
writeRotation(
address,
yaw + delta
)
end
local function handleCommand(line)
if not isCurrent() then
return
end
local parts =
splitLine(line)
local command =
parts[1]
if command == "SESSION_BEGIN" then
startSession()
elseif command == "SESSION_END" then
endSession()
elseif command == "SET_POSITION_RAW" then
setPositionRaw(
tonumber(parts[2]) or 0,
tonumber(parts[3]) or 0,
tonumber(parts[4]) or 0,
tonumber(parts[5]) or 0
)
elseif command == "ROTATE_YAW_RAW" then
rotateYawRaw(
tonumber(parts[2]) or 0
)
end
end
------------------------------------------------------------
-- PROVIDER -> BRIDGE PIPE
------------------------------------------------------------
local function cameraSenderWorker()
local pipe = nil
local sentSequence = -1
while isCurrent() do
if not pipe then
local ok, candidate =
pcall(function()
return connectToPipe(
CAMERA_PIPE_NAME,
0
)
end)
if not isCurrent() then
if ok and candidate then
safeDestroy(candidate)
end
break
end
if ok and candidate then
pipe = candidate
ctx.cameraPipe = pipe
sentSequence = -1
local hello =
"HELLO|Protocol=1" ..
"|Transport=DualPipe" ..
"|Provider=Cheat Engine" ..
"|Engine=" .. CONFIG.engine ..
"|CameraMode=RAW"
if not safeWrite(pipe, hello) then
safeDestroy(pipe)
pipe = nil
ctx.cameraPipe = nil
end
else
sleep(RECONNECT_DELAY_MS)
end
end
if pipe and isCurrent() then
local sequence =
ctx.cameraSequence
local line =
ctx.latestCameraLine
if line and
sequence ~= sentSequence then
if safeWrite(pipe, line) then
sentSequence = sequence
else
safeDestroy(pipe)
pipe = nil
ctx.cameraPipe = nil
sleep(RECONNECT_DELAY_MS)
end
else
sleep(2)
end
end
end
safeDestroy(pipe)
ctx.cameraPipe = nil
end
------------------------------------------------------------
-- BRIDGE -> PROVIDER PIPE
------------------------------------------------------------
local function commandReceiverWorker()
local pipe = nil
local pending = ""
while isCurrent() do
if not pipe then
local ok, candidate =
pcall(function()
return connectToPipe(
COMMAND_PIPE_NAME,
0
)
end)
if not isCurrent() then
if ok and candidate then
safeDestroy(candidate)
end
break
end
if ok and candidate then
pipe = candidate
ctx.commandPipe = pipe
pending = ""
else
sleep(RECONNECT_DELAY_MS)
end
end
if pipe and isCurrent() then
local ok, byte =
pcall(function()
return pipe.readByte()
end)
if not ok then
safeDestroy(pipe)
pipe = nil
ctx.commandPipe = nil
sleep(RECONNECT_DELAY_MS)
elseif byte ~= nil then
if byte == 10 then
local line =
pending
pending = ""
if line:sub(-1) == "\r" then
line =
line:sub(1, -2)
end
if
line ~= "" and
line:sub(1, 7) ~= "WELCOME"
then
synchronize(function()
if isCurrent() then
handleCommand(line)
end
end)
end
else
pending =
pending ..
string.char(byte)
end
end
end
end
safeDestroy(pipe)
ctx.commandPipe = nil
end
------------------------------------------------------------
-- START
------------------------------------------------------------
if IGCSDOF_PROVIDER_CAMERA_TIMER then
IGCSDOF_PROVIDER_CAMERA_TIMER.destroy()
end
IGCSDOF_PROVIDER_CAMERA_TIMER =
createTimer(nil, false)
IGCSDOF_PROVIDER_CAMERA_TIMER.Interval =
CONFIG.cameraIntervalMs or 16
IGCSDOF_PROVIDER_CAMERA_TIMER.OnTimer =
function()
if not isCurrent() then
return
end
processPendingRestore()
ctx.latestCameraLine =
makeCameraLine()
ctx.cameraSequence =
ctx.cameraSequence + 1
end
IGCSDOF_PROVIDER_CAMERA_TIMER.Enabled =
true
ctx.latestCameraLine =
makeCameraLine()
ctx.cameraSequence = 1
ctx.senderThread =
createThread(cameraSenderWorker)
ctx.receiverThread =
createThread(commandReceiverWorker)
ctx.cleanup =
function()
IGCSDOF_SESSION_ACTIVE = false
if ctx.savedCamera then
writeCamera(ctx.savedCamera)
end
releaseProviderLock()
safeDestroy(ctx.cameraPipe)
safeDestroy(ctx.commandPipe)
end
print(
"[IGCSDOF] Universal RAW provider started | Engine=" ..
CONFIG.engine
)
------------------------------------------------------------
-- STOP
--
-- In CT [DISABLE]:
--
-- if IGCSDOF_PROVIDER_STOP then
-- IGCSDOF_PROVIDER_STOP()
-- end
------------------------------------------------------------
IGCSDOF_PROVIDER_STOP =
function()
IGCSDOF_SESSION_ACTIVE = false
local old =
IGCSDOF_PROVIDER_CONTEXTS and
IGCSDOF_PROVIDER_CONTEXTS[myGeneration]
or nil
IGCSDOF_PROVIDER_GENERATION =
(IGCSDOF_PROVIDER_GENERATION or 0) + 1
if IGCSDOF_PROVIDER_CAMERA_TIMER then
IGCSDOF_PROVIDER_CAMERA_TIMER.destroy()
IGCSDOF_PROVIDER_CAMERA_TIMER = nil
end
if old then
old.active = false
if old.cleanup then
pcall(old.cleanup)
end
IGCSDOF_PROVIDER_CONTEXTS[myGeneration] =
nil
end
print(
"[IGCSDOF] Universal RAW provider stopped."
)
end
[DISABLE]
if syntaxcheck then return end
if IGCSDOF_PROVIDER_STOP then
IGCSDOF_PROVIDER_STOP()
end
Toggle Activation
35
0
Code :movsd [rdi],xmm1
OUTRIDERS-Win64-Shipping.exe+31996D4
D1
55
0F
14
CA
F2
0F
11
0F
F3
0F
11
45
A8
Code :movss [rdi],xmm0
OUTRIDERS-Win64-Shipping.exe+38087FA
08
49
8B
73
20
F3
0F
11
07
49
8B
7B
28
49
Code :movss [rsi+08],xmm0
OUTRIDERS-Win64-Shipping.exe+1466BBA
F3
0F
58
46
08
F3
0F
11
46
08
48
8B
BC
24
08
Code :mov [rdi+08],eax
OUTRIDERS-Win64-Shipping.exe+31996E0
45
A8
8B
45
A8
89
47
08
44
0F
B6
8B
3C
Code :movsd [rdi+0C],xmm0
OUTRIDERS-Win64-Shipping.exe+31997A5
83
90
02
00
00
F2
0F
11
47
0C
8B
83
98
02
00
Code :movsd [rsi],xmm0
OUTRIDERS-Win64-Shipping.exe+38087E9
54
49
8B
6B
18
F2
0F
11
06
F3
0F
10
44
24
Code :mov [rdi+14],eax
OUTRIDERS-Win64-Shipping.exe+319980F
24
90
02
00
00
89
47
14
F6
83
0C
03
00
Code :mov [rdi+28],eax
OUTRIDERS-Win64-Shipping.exe+35FDDD4
83
38
03
00
00
89
47
28
8B
83
40
03
00
Code :movss [rdi+18],xmm0
OUTRIDERS-Win64-Shipping.exe+3199835
83
F8
02
00
00
F3
0F
11
47
18
8B
83
08
03
00
Code :mov [rsi+18],eax
OUTRIDERS-Win64-Shipping.exe+14754DE
BB
C8
08
00
00
89
46
18
F6
83
0C
03
00
Code :mov [rbp+08],eax
OUTRIDERS-Win64-Shipping.exe+38087DE
0F
10
44
24
4C
89
45
08
8B
44
24
54
49
Code :movss [rbx+000000C4],xmm0
OUTRIDERS-Win64-Shipping.exe+30F9CDB
58
59
01
33
D2
F3
0F
11
83
C4
00
00
00
41
0F
B6
47
30
Code :mov [rax+04],ecx
OUTRIDERS-Win64-Shipping.exe+374A9DA
7E
03
8B
4F
38
89
48
04
41
F7
D0
FF
47
speedModifier
2413E550000