fransbouma / injectablegenericcamerasystem

This is a generic camera system to be used as the base for cameras for taking screenshots within games. The main purpose of the system is to hijack the in-game 3D camera by overwriting values in its camera structure with our own values so we can control where the camera is located, it's pitch/yaw/roll values, its FoV and the camera's look vector.

Injectable Generic Camera System

This is a generic injectable camera system which is used as a base for cameras for taking screenshots within games. The main purpose of the system is to hijack the in-game 3D camera by overwriting values in its camera structure with our own values so we can control where the camera is located, it's pitch/yaw/roll values, its FoV and the camera's look vector. Some camera implementations have additional features like timestop.

It's written in C++ with some x86/x64 assembler to be able to intercept the location of the 3D camera in the game. The system is initially designed for 64bit hosts as all games are 64bit nowadays, but has been reworked to be used for 32bit games too.

Re-hosting binaries

All binaries of my tools are available through my Patreon, unless stated otherwise. You're not allowed to re-host the binaries on other modsites, like Nexus Mods.

Folder structure description

In the folder Cameras you'll several implementations of the system, adapted for specific games.

The cameras don't use a shared piece of code as in general cameras have to be adapted to a game pretty deeply and I didn't want to make a big configurable ball. Additionally, cameras are often written once and perhaps fixed once or twice when the game is updated, but that's it. Copying the code for each camera and adapting it makes possible to add new features to future cameras without affecting the older ones.

Requirements to build the code

To build the code, you need to have VC++ 2017 or higher, newer cameras need VC++ 2019. Additionally you need to have installed the Windows SDK, at least the windows 8 version. The VC++ installer should install this. The SDK is needed for DirectXMath.h

External dependencies

There's an external dependency on MinHook through a git submodule. This should be downloaded automatically when you clone the repo. The camera uses DirectXMath for the 3D math, which is a self-contained .h file, from the Windows SDK.

Commercial usage

These cameras and its system are made by volunteers in their spare time. If you use these camera for commercial activities (e.g. you make money with the shots or videos you produce with this camera), consider a donation or joining my Patreon

Support

If you want support for a camera, please join my Patreon where I have a tier available for support on cameras.

Camera's released:

• Assassin's Creed 3: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/AssassinsCreed3
• Assassin's Creed Odyssey: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/AssassinsCreedOdyssey
• Assassin's Creed Origins: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/AssassinsCreedOrigins
• Batman Arkham Knight: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/BatmanArkhamKnight
• Bulletstorm Full Clip Edition: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/BulletstormFCE
• Cyberpunk 2077: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Cyberpunk2077
• Deus Ex: Mankind Divided: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/DXMD
• Devil May Cry 5: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/DMC5
• Dishonored 2: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Dishonored2
• DOOM x64: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/DOOM
• Dying Light: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/DyingLight
• GreedFall: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Greedfall
• Hellblade: Senua's Sacrifice: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Hellblade
• Hitman 2016: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Hitman2016
• Homefront: The Revolution: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/HomefrontTheRevolution
• Injustice 2: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Injustice2
• Kingdom Come Deliverance: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/KingdomComeDeliverance
• Lords of the Fallen: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/LordsOfTheFallen
• Mafia III: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Mafia3
• Metal Gear Solid V: The Phantom Pain: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/MGS5
• Metro Exodus: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/MetroExodus
• Prey (2017): https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Prey
• Resident Evil 2: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/ResidentEvil2
• Resident Evil 3: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/ResidentEvil3
• Ryse: Son of Rome: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/RyseSonOfRome
• Shadow of the Tomb Raider: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/SOTTR
• The Evil Within 2: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/TEW2
• Titanfall 2: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Titanfall2
• Tomb Raider 2013: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Tombraider
• Watch_Dogs: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Watch_Dogs
• Watch_Dogs2: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Watch_Dogs2
• Wolfenstein II: The new colossus: https://github.com/FransBouma/InjectableGenericCameraSystem/tree/master/Cameras/Wolfenstein2

In-depth article about IGCS and how to create camera tools

I've written a long, in-depth article about how to create camera tools and how IGCS works on my blog.

Acknowledgements

Some camera code uses MinHook by Tsuda Kageyu.

Patreon

I do this for fun, not profit, but can't create cameras for games I don't own. I've therefore setup a Patreon page which allows you to safely support my work now and in the future and in return you get access to binary releases, early access to newer cameras and if you opt for that, support.

injectablegenericcamerasystem's Issues

Make look orientation configurable to be inverted

Invert x / y based on settings / keystroke

Also make rotation / speed configurable e.g. through settings or keystrokes

.exe is not working

The Extreme Injector v3.exe is not opening, any solutions?
I want something simple to be able to make screenshots, but I dont want to use cheat engine >_<

Watch_Dogs: fov should only be overwritten when camera is active

As the FoV is used by the cameras you can hack and also the sniper rifles, it's not really helpful to overwrite the FoV write as we do in v1.0.1 of the camera: it should be intercepted only when the camera is enabled.

Hitman: ET release for v1.9 breaks camera.

The camera is broken since the last ET release of v1.9.0. they fixed apparently some things (the weird 0 byte in the camera write code is gone for instance), but it broke the camera.

Hitman 2016 Timestop

I know this is no longer a supported game, but the tools do still work. Just one problem: After using the tool for about 30 mins the timestop tool (Num 0) suddenly stopped working, and neither reinstalling the game nor wiping my graphics drivers could restore it.

Any ideas on what I can delete to reset the tool?

Contribution for more precision. FOV Speed Modifer and slower speed with Ctrl.

Thank you so much for this tool!

I only made the change to the Hitman keyboard camera. Feel free to transfer it to Tomb raider and the controller cameras as well.
Feel free to clean up/adapt/rename/change/dispose of the code as you see fit.
https://github.com/HMBM47/InjectableGenericCameraSystem

And if you're so inclined, check out some screens I've made with your tool:
http://www.hitmanforum.com/t/the-hitman-screenshot-thread/145/910
Others on the thread are putting it to good use as well.

Link VCRuntime statically instead of dynamically

It's currently linked dynamically, which requires the user to have a VCRuntime140 to be present on the system. This is likely the case as the games themselves require it most likely, but we can also link it statically without running the risk of a missing reference at runtime.

Tomb Raider 2013 Cheat Table

Edit: https://community.pcgamingwiki.com/files/file/1148-tomb-raider-2013-fov-cheat-table/

DOOM camera is broken after latest patch

The DOOM camera is broken after the latest patch. It's not AOB scanned so it might need re-scanning for the camera struct

Prey 2017 camera tools - Not Working

The injector dont work because the game version is different (I think they updated the game after Mooncrash release)

Hitman: Broken again on latest update

Pressing INS results in nothing happening.

Edit: I think it's the 1.9.1 update, but it still says 1.9.0 in-game? Weird.

Does this project support Hitman™ 2?

Does this project support Hitman™ 2?

Add link to vc14 runtime in readme as it's required

this link: https://www.microsoft.com/en-us/download/details.aspx?id=48145

Not always required, modern games already install it, but older games don't. We could also statically link to the lib...

Hitman Sniper Assassin

Would it be possible to update the freecam for Hitman so it works with Hitman Sniper Assassin as well? It's using the same game engine.

Watch Dogs 2 injector doesn't work

I run it as admin and it doesn't open a console or nothing, nothing happens in game. I disabled EAC correctly the HUD correction works fine, but the injector doesn't work. same for ROTTR extreme injector just doesn't work for me, any fixes?

Homefront2: Mouse cursor stays on screen even when the UI is closed

This is likely caused by the flag in ImGui which says to render the mouse cursor even when the window is closed.

Hitman 2016: Linux support?

I would like to be able to use this on the Linux build of the game. Is there any chance at all a Linux port will be made in the future?

Thanks,
Josh

[All] Implement keybind config through a text file.

Currently keys are bound hard-coded and if one wants to use different keybinds, e.g. because they conflict with other setups, it's not possible to do.

A simple ini file would do.

Alt+Tab = Main Menu

Hi, I wonder if there is a simple solution for when you pause the game with the Num 0 Button, choose the positioning for shotting and etc, but when you alt tab to turn on the SRWE custom res, the game goes to the main menu and the only way to close it is pressing Insert again, and returning to the desired position is kind hard with the srwe screen. I'm kinda new in these things, am I doing something wrong? There is a better way to deal with it? Thanks. Your Cam tool is incredible btw, great job!

New cameras: add invincible/immortal cheat to camera tools for action shots.

It can help greatly with action shots if the player is invincible. These are often easy to find.

Use simpler trick to write bytes to memory and flush cache

See: https://twitter.com/dez_/status/938074904666271744

Trick uses memcpy with a string, no need for byte array. Also issues FlushInstructionCache, which we also don't do.

Overlay: Add configuration for movement / rotation speeds

For people who want to use the camera for video recording it's a bit cumbersome to not have fine-grained control over camera movement speed and camera smoothing.

the mouse smoothing was originally in the code when we're using directinput, we can port that back. the camera movement speed can be controlled as well with the mousewheel and keyboard keys so camera movement can be set to a speed that's usable for a given scene.

Mainly for hitman as people use that for videos as well. But future cameras can be using this code as well.

Hitman2016 camera: Ctrl or RB not a good way to do slower movement

The game still registers the RB or ctrl keypress, which will reset the timestop so this should be another key. Like shift and A.

Chunked frustum rendering ("Super resolution")

We could use the same method nvidia ansel uses to render higher-than-viewport-resolution screenshots by dividing the view frustum into different "chunks" and then stitching them into a single image. Figure stitching a panorama but without applying any image distortion.

there will have to be some overlap between the chunks to allow for blending of things like lens flare and other screen space effects.

https://computergraphics.stackexchange.com/questions/8500/modify-camera-matrix-so-that-it-renders-a-chunk-of-the-frustum

A better camera for dishonored 2 and potentially dishonored doto

Camera properties:
I've seen this take two rcx addresses on the menu screen.

Dishonored2.exe+A0F8D0 - 40 53                 - push rbx
Dishonored2.exe+A0F8D2 - 48 83 EC 70           - sub rsp,70 { 112 }
Dishonored2.exe+A0F8D6 - 8B 02                 - mov eax,[rdx]
Dishonored2.exe+A0F8D8 - 0F57 C9               - xorps xmm1,xmm1
Dishonored2.exe+A0F8DB - 48 8B D9              - mov rbx,rcx
Dishonored2.exe+A0F8DE - 89 81 A8000000        - mov [rcx+000000A8],eax { Camera x write }
Dishonored2.exe+A0F8E4 - 8B 42 04              - mov eax,[rdx+04]
Dishonored2.exe+A0F8E7 - 4C 8D 4C 24 40        - lea r9,[rsp+40]
Dishonored2.exe+A0F8EC - 89 81 AC000000        - mov [rcx+000000AC],eax { Camera y write }
Dishonored2.exe+A0F8F2 - 8B 42 08              - mov eax,[rdx+08]
Dishonored2.exe+A0F8F5 - 89 81 B0000000        - mov [rcx+000000B0],eax { Camera vertical position write }
Dishonored2.exe+A0F8FB - 8B 02                 - mov eax,[rdx]
Dishonored2.exe+A0F8FD - 89 81 C0000000        - mov [rcx+000000C0],eax { Duplicated coords }
Dishonored2.exe+A0F903 - 8B 42 04              - mov eax,[rdx+04]
Dishonored2.exe+A0F906 - 89 81 C4000000        - mov [rcx+000000C4],eax { ... }
Dishonored2.exe+A0F90C - 8B 42 08              - mov eax,[rdx+08]
Dishonored2.exe+A0F90F - 89 81 C8000000        - mov [rcx+000000C8],eax { ... }
Dishonored2.exe+A0F915 - 41 8B 00              - mov eax,[r8]
Dishonored2.exe+A0F918 - 89 81 CC000000        - mov [rcx+000000CC],eax { mat 0,0 write }
Dishonored2.exe+A0F91E - 41 8B 40 04           - mov eax,[r8+04]
Dishonored2.exe+A0F922 - 89 81 D0000000        - mov [rcx+000000D0],eax { ... }
Dishonored2.exe+A0F928 - 41 8B 40 08           - mov eax,[r8+08]
Dishonored2.exe+A0F92C - 89 81 D4000000        - mov [rcx+000000D4],eax
Dishonored2.exe+A0F932 - 41 8B 40 0C           - mov eax,[r8+0C]
Dishonored2.exe+A0F936 - 89 81 D8000000        - mov [rcx+000000D8],eax
Dishonored2.exe+A0F93C - 41 8B 40 10           - mov eax,[r8+10]
Dishonored2.exe+A0F940 - 89 81 DC000000        - mov [rcx+000000DC],eax
Dishonored2.exe+A0F946 - 41 8B 40 14           - mov eax,[r8+14]
Dishonored2.exe+A0F94A - 89 81 E0000000        - mov [rcx+000000E0],eax
Dishonored2.exe+A0F950 - 41 8B 40 18           - mov eax,[r8+18]
Dishonored2.exe+A0F954 - 89 81 E4000000        - mov [rcx+000000E4],eax
Dishonored2.exe+A0F95A - 41 8B 40 1C           - mov eax,[r8+1C]
Dishonored2.exe+A0F95E - 89 81 E8000000        - mov [rcx+000000E8],eax
Dishonored2.exe+A0F964 - 41 8B 40 20           - mov eax,[r8+20]
Dishonored2.exe+A0F968 - 89 81 EC000000        - mov [rcx+000000EC],eax { mat 3,3 write }
Dishonored2.exe+A0F96E - C6 81 C0390000 01     - mov byte ptr [rcx+000039C0],01 { 1 }
Dishonored2.exe+A0F975 - 48 8B 0D 3CE6C801     - mov rcx,[Dishonored2.exe+269DFB8] { [2985DB55BB0] }
Dishonored2.exe+A0F97C - F3 41 0F10 40 08      - movss xmm0,[r8+08]
Dishonored2.exe+A0F982 - F3 41 0F10 50 04      - movss xmm2,[r8+04]
Dishonored2.exe+A0F988 - F3 41 0F10 20         - movss xmm4,[r8]
Dishonored2.exe+A0F98D - 0F14 D1               - unpcklps xmm2,xmm1
Dishonored2.exe+A0F990 - 0F14 E0               - unpcklps xmm4,xmm0
Dishonored2.exe+A0F993 - 48 8D 05 D6454C01     - lea rax,[Dishonored2.exe+1ED3F70] { ["player"] }
Dishonored2.exe+A0F99A - F3 41 0F10 40 20      - movss xmm0,[r8+20]
Dishonored2.exe+A0F9A0 - F3 41 0F10 58 18      - movss xmm3,[r8+18]
Dishonored2.exe+A0F9A6 - 0F14 E2               - unpcklps xmm4,xmm2

As for pausing the game, the game has a simulation timescale value that when set to 0 all entity updating is suspended (including the code that writes to the camera values). To capture this value I used an AOB injection script on cheat engine, this is what it looks like:

{ Game   : Dishonored2.exe
  Version: 
  Date   : 2018-12-26
  Author : fakui

  This script captures the "engine timings" struct
}

[ENABLE]

aobscanmodule(engine_timings_hook,Dishonored2.exe,F2 0F 11 4B 18 F2 0F 5C) // should be unique
alloc(newmem,$1000,"Dishonored2.exe"+7DFEE)

label(code)
label(return)
label(EngineTimings)
registersymbol(EngineTimings)

newmem:
  mov [EngineTimings],rbx
  jmp code

EngineTimings:
  dq 0

code:
  movsd [rbx+18],xmm1
  jmp return

engine_timings_hook:
  jmp newmem
return:
registersymbol(engine_timings_hook)

[DISABLE]

engine_timings_hook:
  db F2 0F 11 4B 18

unregistersymbol(engine_timings_hook)
unregistersymbol(EngineTimings)
dealloc(newmem)

{
// ORIGINAL CODE - INJECTION POINT: "Dishonored2.exe"+7DFEE

"Dishonored2.exe"+7DFB9: 48 89 44 24 38              -  mov [rsp+38],rax
"Dishonored2.exe"+7DFBE: FF 15 1C 66 BC 01           -  call qword ptr [Dishonored2.exe+1C445E0]
"Dishonored2.exe"+7DFC4: 48 8B 44 24 30              -  mov rax,[rsp+30]
"Dishonored2.exe"+7DFC9: 0F 57 C9                    -  xorps xmm1,xmm1
"Dishonored2.exe"+7DFCC: 0F 57 C0                    -  xorps xmm0,xmm0
"Dishonored2.exe"+7DFCF: F2 48 0F 2A 05 F0 42 64 02  -  cvtsi2sd xmm0,[Dishonored2.exe+26C22C8]
"Dishonored2.exe"+7DFD8: 48 2B 05 F1 42 64 02        -  sub rax,[Dishonored2.exe+26C22D0]
"Dishonored2.exe"+7DFDF: F2 48 0F 2A C8              -  cvtsi2sd xmm1,rax
"Dishonored2.exe"+7DFE4: F2 0F 5E C8                 -  divsd xmm1,xmm0
"Dishonored2.exe"+7DFE8: F2 0F 58 4C 24 38           -  addsd xmm1,qword ptr [rsp+38]
// ---------- INJECTING HERE ----------
"Dishonored2.exe"+7DFEE: F2 0F 11 4B 18              -  movsd [rbx+18],xmm1
// ---------- DONE INJECTING  ----------
"Dishonored2.exe"+7DFF3: F2 0F 5C 4B 08              -  subsd xmm1,[rbx+08]
"Dishonored2.exe"+7DFF8: 66 0F 5A C1                 -  cvtpd2ps xmm0,xmm1
"Dishonored2.exe"+7DFFC: F3 0F 11 44 24 30           -  movss [rsp+30],xmm0
"Dishonored2.exe"+7E002: 8B 44 24 30                 -  mov eax,[rsp+30]
"Dishonored2.exe"+7E006: C7 44 24 30 00 00 00 00     -  mov [rsp+30],00000000
"Dishonored2.exe"+7E00E: 89 43 28                    -  mov [rbx+28],eax
"Dishonored2.exe"+7E011: 8B 44 24 30                 -  mov eax,[rsp+30]
"Dishonored2.exe"+7E015: C7 44 24 30 00 00 00 00     -  mov [rsp+30],00000000
"Dishonored2.exe"+7E01D: 89 43 78                    -  mov [rbx+78],eax
"Dishonored2.exe"+7E020: 8B 44 24 30                 -  mov eax,[rsp+30]
}

However this code is not executed on the menu screen. We should look for a more reliable one.

The time scale variable can now be accessed at offset 0x110 from EngineTimings

Hitman 2016: Re-add alt timestop, as fov can be forced with resolution change

Re-add the alternative timestop. Resolution change will force fov to be applied. Cumbersome but works.

No mirrors will work.

Why the Hitman version says there are new versions of this program but I didn't see source code updated here?

Why the Hitman version says there are new versions of this program but I didn't see source code updated here?

By the way, the dialog seems doesn't want to popup twice. Now I cannot find the URL it told me to download ...

TombRaider 2013. AR correction fix

(Contributed by IDK31)

//"TombRaider.exe"+67F670
[ENABLE]

aobscanmodule(arAOB,TombRaider.exe,88 57 04 89 71 08)
alloc(newmem,$1000)

label(code)
label(return)

newmem:

code:
  mov [edi+04],0 //mov [edi+04],dl
  mov [ecx+08],esi
  jmp return

arAOB:
  jmp newmem
  nop
return:
registersymbol(arAOB)

[DISABLE]

arAOB:
  db 88 57 04 89 71 08

unregistersymbol(arAOB)
dealloc(newmem)

Signatures changes

Hi,
Today's patch broke the camera (Along with Mooncrash update).
I suppose structures' signature are different now.
Any chance for fix?

Cheers.

Hitman 2016: Bangkok level has missing boats due to misaligned interceptor indices

The statements for the 2nd interceptor are off, the first statement isn't correct.

Implement overlay for console, help and configuration

Use ImGui for this. The work for this issue is done in the OverlayTest branch.

Add xbox button trigger (use undocumented code in winapi) to enable camera w/ controller

See: https://forums.tigsource.com/index.php?topic=26792.0

The way it should work: when pressing the xbox button on the controller, the camera should enable, the game should pause and input from the controller should block. This is close to how an in-game photomode would work. You can then go move the camera around right away by a single button press.

Might be best to simply use the WM_INPUT route, as we already hook raw input. Not sure what key is detected when pressing that button, but it's easy to find out.

Changing FOV outside the freecam doesn't work.

Before I had the option to change the FOV while still having the camera locked onto 47 during gameplay. Doesn't work anymore. Pressing Insert only enables the freecam.

Add better input blocking through API hooking

Use minhook (https://github.com/TsudaKageyu/minhook/) to intercept XInput's XInputGetState() and the 4 message retrieve functions in User32 (GetMessage and peek message and variants). In the detour functions (our own versions) do the following:

• Always first call the original ones (trampoline versions).
• For the message functions: Handle messages there. Do it in all functions, as it might be the host only calls peek or only get. If input blocking is enabled, return WM_NULL to make the function result in a NOP for the host, otherwise simply return the result of the call to the original version
• For XInputGetState, first call the original. Store the result as the next result to use for our Gamepad.cpp code. If input is blocked, simply zero the block returned from the original, otherwise return the block returned from the original.
• If input is blocked, any mouse / keyboard message received in the detour versions has to be replaced by WM_NULL. See reshade's input.cpp for ideas how to do that.

Additional work

• register the main window for rawinput. It might be that's not done by the host. We need raw input for our own input.
• handle mouse and keyboard raw input as our main input for mouse/keyboard. Tombraider camera has mouse raw input handling (so we can port that to the main src) but not raw keyboard handling: it relies on GetKeyState(). This might be sufficient, test whether this is needed.

[Hitman] Version 1.9.0 Broke the Camera System

Just as I discovered the fact that someone made a rather awesome camera system for the newest HITMAN, version 1.9.0 that launched on January 31st came out.

I tried injecting the camera into HITMAN but it seems the update has done broke it as it gets stuck on "Waiting for camera struct interception..."

Figured I'd open an issue so this is known about.

Hitman: add gamespeed control through keyboard via timestop variable

Timestop is done with a float, and it's doable to make that control the gamespeed. This is useful for people who want to use the camera tools for creating videos.

All new cameras: Add camera path editing for movie recording

Hatti's BF1 tools have this, and it's really cool.

Basically it should work like this:
(All quaternions are unit quaterions. We already do this, but just in case we're not, they have to be normalized)

• User clicks start-camera path
• There's a user key to add path nodes. In-game, when the freecam is enabled, when a path is active, and the user presses the specific key, a pathnode is added at the location of the freecam, with the quaterion it has at that location, and the location itself in worldcoords. This is stored with the path
• There's an active move speed value. It's stored with a newly created path node. The speed is actually a value how many interpolations in a second are done between two path nodes. Faster speed means lower # of interpolations. See below.
• When the user is done creating the path, s/he clicks a button and the path consists of the start node, end node and all nodes in between.
• the user can now start 'play' to play the camera movement over the path, where the camera is moved from path node to path node, over an interpolated beziercurve.
• Use DirectX math lib's quaternion slerp function to calculate new interpolated quaternions between path nodes at x intervals, where x is calculated from the move speed of start and end node of a path part. This is the camera rotation part. The coordinates are calculated from the beziercurve through the path nodes.

Calculating the speed.

As smooth play requires a ticker, we can calculate based on the time taken between frames the time needed to play y units. E.g. if we play on 30hz, and we have a 60fps framerate, we get a new tick every 2 frames. If the speed is 10, we can define e.g. that '10' means we move 10 units per tick. If the speed is 5, we move 5 units per tick. the lower the value, the more interpolations are done between two nodes in a path.

We have to come up with a formulate for this, but it looks rather straightforward. It's either a lower-boundary on the speed (the 'slowest' one can move) or a higher-boundary on the speed (the maximum one can move).

Papers / Guides

See Catmull-Rom/Overhauser splines: https://www.codeproject.com/Articles/30838/Overhauser-Catmull-Rom-Splines-for-Camera-Animatio They're superior for this.

See: https://graphicsrunner.blogspot.nl/2008/05/camera-animation-part-ii.html

Also:
See: https://www.engr.colostate.edu/ECE481A2/Readings/Rotation_Animation.pdf (or equivalent)
See: https://www.scss.tcd.ie/publications/tech-reports/reports.94/TCD-CS-94-18.pdf (bezier/bspline based camera paths)

Todo

Bezier curves/spline curves for interpolation between multiple nodes on a path. See e.g. https://gamedev.stackexchange.com/questions/64529/camera-movement-with-slerp

Lords of the Fallen

Sorry for the odd question, but can the camera tools be used as an "FOV fix" for playing through the game (i.e. without freecam enabled)? There used to be a Cheat Engine table for changing the FOV, but I saw reports that it doesn't work anymore with the latest version of the game. So I'm looking for a way to change only that, without the other features.

Watch_Dogs: crash in 1.0.0 camera due to jmp into rerouted codeblock

A codeblock which was rerouted into the interceptor to grab an address in a register received a jmp into the middle of it, which caused a game crash due to the code being overwritten with the jmp qword ptr [address] statement.

All cameras: add option to block KB/M and Controller input individually

Currently it's a single key to block both KB/M and Controller (Numpad .) This is restrictive, if people want to use controller for camera but KB/M for player movement.

Create two flags, not one: one for KB/M blocking and one for Controller blocking. Internally the blocking code for the two systems check their own flag. Numpad. toggles both flags. Ctrl-Numpad. toggles controller specific flag, Alt-Numpad. toggles KB/M specific flag.

Don't make a mess of the flags: if someone presses Ctrl-Numpad. to switch off controller input, and then Numpad. it should switch off both and not toggle ON controller input and OFF KB/M input: do an OR of the two flags and use that as the new value for general Numpad. presses.

[Hitman] DirectX12 support

Hi,

Do you plan to add Direct3D12 support in your injection tool for HITMAN™ game ?

Great work and awesome tool btw ! Like it 👍
It reminds me my work on a basic object viewer with freecam system :) (study work)

Hitman get an update two days ago. Camera doesn't work again.

As title says Hitman has received a new update. When you can, could you please update the injector?

Thanks :)

[Hitman] Decrease fov change speed

The fov speed movement is a bit high. Decrease it as it's not really needed to be that fast.

All cameras: Make it possible to select camera control device (and auto-block it)

Currently KB/M and controller are always selected for camera control. However, if the user wants to record a video this isn't useful: KB/M should be player and Controller for camera or vice versa.

By default 'All' devices are selected. The user should be able to cycle through the devices by using a key, e.g. Numpad . When that key is pressed, the next device in line is selected.

It then also should auto-block input from that device to the game, as why would you not want to block input to the game if that device is selected?

So numpad . can be used for that. We can either use: Numpad. + Alt/Ctrl or use multiple presses of Numpad. to select the device. The Alt/Ctrl combination looks easier.

Watchdogs 2 Camera has broken hotsampling after latest patch

The hotsampling AOB scan is currently broken

Lords of the fallen injector insta crash

I'll run the game and injector as admin the injector never shows on screen but under processes on task manager it shows up for a couple seconds before disappearing. Video showing what happens: https://youtu.be/D1oS0gK-xWY

Scriptable (?) multi-image lightfield capture

Hi!

I've spent about a day playing around with lightfield game capture for the Looking Glass 3D display (i'm an employee there) and I'm interested in using a system like IGCS to get perfect screenshots rather than fumbling around in the developer console or worse, moving my character around in the game.
Our system is very similar to a stereo/parallax display, where you take two photos from slightly different angles and superimpose them to create a depth illusion, but rather than displaying 2 views it actually superimposes 45 images at once.
So - what's required for the image capture is actually very simple. All I need is a method through which I can repeatedly move the camera a fixed distance left and right, taking a screenshot each time. To set the distance between pictures, I'd ideally like to patch in an additional variable parameter which can be adjusted from the imgui. It looks like I just need to drop in a bit of extra code in Input.cpp and CameraManipulator.cpp to repeatedly call Camera::moveRight and Camera::moveLeft. But, as I need to save an image between every movement, I don't know if there is a straightforward way to dump framebuffer to image directly from the injected code? Ideally this capture process would be near-instant, so I wouldn't need to press the screenshot button 45 times for it to work.
I'm happy to hack at the source code a little bit, but I'm wondering if there's anything I should be aware of that might make the process easier, i.e., unimplemented functions that dump framebuffer to file, or a way to move the camera to an exact position relative to its current one. I noticed you were planning a feature basically identical to this idea in another issue, and this seems like a simpler version of that as we don't need to account for a curved path or smooth motion.
This is a really amazing project and I'm super excited to get some amazing 3D captures, so thanks for working on it!

how do i make this to work?

where do i put the files to make it work?
Thx!

Prey Camera has broken FoV after latest patch

The FOV AOB scan isn't picked up anymore

AC Odyssey time stop

When using the camera tool for AC Odyssey, the in-game timer automatically freezes. I wanted to do some timelapse videos but found out that the time is frozen and I'm only able to make it move forward by adjusting the cursor in the tool. However, the tool is then captured by any screen recording software and the timelapse isn't possible anymore.