// This file is part of ClassicAPI.
//
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software Foundation, either
// version 3 of the License, or (at your option) any later version.
//
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// ClassicAPI. If not, see .
// `PlayerModel:SetPortraitZoom(zoom)`, `SetCamDistanceScale(scale)` and
// `RefreshCamera()` — 4.3.4's CGCharacterModelBase camera methods.
//
// Vanilla's pane camera is ConfigureCamera (FUN_PLAYERMODEL_CONFIGURE_CAMERA),
// run when the pane's model is ready: a frozen copy of the model's camera 1,
// or a fixed camera aimed at the bounding-box centre. 4.3.4's ConfigureCamera
// (CharacterModelBase.cpp, 0x00A03790) is that same choice followed by two
// steps, ported here verbatim onto the installed camera:
//
// - portrait zoom: move eye, target and field of view from the pane camera
// toward the model's portrait camera (id 0) by `zoom` — 1 frames the head
// the way unit-frame portraits do;
// - distance scale: scale the eye's distance from the target by `scale`,
// floored at 0.1 and kept at least 0.1 yards out.
//
// Both run in a co-hook after the original, so a pane with the defaults (zoom
// 0, scale 1) keeps vanilla's camera untouched. Vanilla has no room for the
// two values in the pane, so they live in a side table keyed by frame.
//
// Before reading the portrait camera, the model is animated once with the
// frame's facing at 0 — the pass ConfigureCamera itself runs before it copies
// camera 1, and the one the engine's portrait baker (BakePortrait 0x00525200)
// runs before it reads camera 0. 4.3.4 subtracts the frame's position from
// both model cameras; vanilla's ConfigureCamera does not subtract it from
// camera 1, so the portrait camera is used as is, in the same space.
#include "model/Camera.h"
#include "Game.h"
#include "Offsets.h"
#include
#include
#include
namespace Model::Camera {
namespace {
struct Settings {
float portraitZoom = 0.0f;
float distanceScale = 1.0f;
};
std::unordered_map g_settings;
using GetVector_t = void(__fastcall *)(void *camera, uint32_t id, float *out);
using GetScalar_t = float(__fastcall *)(void *camera, uint32_t id);
using SetVector_t = void(__fastcall *)(void *camera, uint32_t id, const float *value,
uint32_t keep);
using SetScalar_t = void(__fastcall *)(void *camera, uint32_t id, float value);
using GetCameraCount_t = uint32_t(__thiscall *)(void *model);
using GetCamera_t = void *(__thiscall *)(void *model, uint32_t index);
using LookupIndex_t = uint16_t(__fastcall *)(uint32_t id, const void *table);
using SetAnimated_t = void(__thiscall *)(void *model, int animated);
using GetScene_t = void *(__thiscall *)(void *frame);
using SceneAnimate_t = void(__thiscall *)(void *scene, const float *cameraPos);
using UpdateModel_t = void(__thiscall *)(void *frame);
using ModelLoaded_t = int(__thiscall *)(void *model, int tryLoad, int recurseChildren);
using ConfigureCamera_t = void(__thiscall *)(void *pane);
} // namespace
// GetCameraById's lookup, bounded the way 4.3.4 null-checks its result.
void *CameraById(void *model, uint32_t id) {
const uint32_t count =
reinterpret_cast(Offsets::FUN_M2MODEL_GET_CAMERA_COUNT)(model);
const uint8_t *data = Game::Read(
Game::Read(model, Offsets::OFF_M2MODEL_SHARED), Offsets::OFF_M2SHARED_DATA);
const uint16_t index = reinterpret_cast(Offsets::FUN_M2_LOOKUP_INDEX)(
id, data + Offsets::OFF_M2DATA_CAMERA_ID_LOOKUP);
if (index >= count)
return nullptr;
return reinterpret_cast(Offsets::FUN_M2MODEL_GET_CAMERA)(model, index);
}
namespace {
struct Vec3 {
float x, y, z;
};
Vec3 GetVector(void *camera, uint32_t id) {
Vec3 v{};
reinterpret_cast(Offsets::FUN_CAMERA_GET_VECTOR)(camera, id, &v.x);
return v;
}
void SetVector(void *camera, uint32_t id, const Vec3 &v) {
reinterpret_cast(Offsets::FUN_CAMERA_SET_VECTOR)(camera, id, &v.x, 0);
}
float GetScalar(void *camera, uint32_t id) {
return reinterpret_cast(Offsets::FUN_CAMERA_GET_SCALAR)(camera, id);
}
void SetScalar(void *camera, uint32_t id, float value) {
reinterpret_cast(Offsets::FUN_CAMERA_SET_SCALAR)(camera, id, value);
}
// ConfigureCamera's own evaluation pass: facing 0, rebuild the root
// transform, animate the scene, restore the facing.
void AnimateUnrotated(void *pane, void *model) {
float &facing = Game::Ref(pane, Offsets::OFF_SIMPLEMODEL_FACING);
const float saved = facing;
facing = 0.0f;
const void *vtable = Game::Read(pane, 0);
Game::Read(vtable, Offsets::VTBL_SIMPLEMODEL_UPDATE_MODEL)(pane);
reinterpret_cast(Offsets::FUN_M2MODEL_SET_ANIMATED)(model, 1);
const float origin[3] = {0.0f, 0.0f, 0.0f};
void *scene = reinterpret_cast(Offsets::FUN_SIMPLEMODEL_GET_SCENE)(pane);
reinterpret_cast(Offsets::FUN_M2SCENE_ANIMATE)(scene, origin);
facing = saved;
}
Vec3 Lerp(const Vec3 &from, const Vec3 &to, float t) {
return {(to.x - from.x) * t + from.x, (to.y - from.y) * t + from.y,
(to.z - from.z) * t + from.z};
}
// 4.3.4 ConfigureCamera's last two steps, on the camera vanilla installed.
void ApplySettings(void *pane, const Settings &s) {
void *model = Game::Read(pane, Offsets::OFF_SIMPLEMODELFFX_MODEL_INSTANCE);
void *camera = Game::Read(pane, Offsets::OFF_SIMPLEMODEL_CAMERA);
if (model == nullptr || camera == nullptr)
return;
if (s.portraitZoom != 0.0f) {
AnimateUnrotated(pane, model);
if (void *portrait = CameraById(model, 0)) {
const Vec3 eye = GetVector(camera, Offsets::CAMERA_PROP_EYE);
const Vec3 target = GetVector(camera, Offsets::CAMERA_PROP_TARGET);
const float fov = GetScalar(camera, Offsets::CAMERA_PROP_FOV);
const Vec3 portraitEye = GetVector(portrait, Offsets::CAMERA_PROP_EYE);
const Vec3 portraitTarget = GetVector(portrait, Offsets::CAMERA_PROP_TARGET);
const float portraitFov = GetScalar(portrait, Offsets::CAMERA_PROP_FOV);
SetVector(camera, Offsets::CAMERA_PROP_EYE, Lerp(eye, portraitEye, s.portraitZoom));
SetVector(camera, Offsets::CAMERA_PROP_TARGET,
Lerp(target, portraitTarget, s.portraitZoom));
SetScalar(camera, Offsets::CAMERA_PROP_FOV,
(portraitFov - fov) * s.portraitZoom + fov);
}
}
if (s.distanceScale != 1.0f) {
const Vec3 eye = GetVector(camera, Offsets::CAMERA_PROP_EYE);
const Vec3 target = GetVector(camera, Offsets::CAMERA_PROP_TARGET);
const float scale = s.distanceScale < 0.1f ? 0.1f : s.distanceScale;
const float dx = eye.x - target.x;
const float dy = eye.y - target.y;
const float dz = eye.z - target.z;
float sx = dx * scale;
float sy = dy * scale;
float sz = dz * scale;
if (sz * sz + sy * sy + sx * sx < 0.010000001f) {
const float inv = 1.0f / std::sqrt(dy * dy + dz * dz + dx * dx);
sx = dx * inv * 0.1f;
sy = dy * inv * 0.1f;
sz = dz * inv * 0.1f;
}
SetVector(camera, Offsets::CAMERA_PROP_EYE, {sx + target.x, sy + target.y, sz + target.z});
}
}
ConfigureCamera_t g_origConfigureCamera = nullptr;
void __fastcall ConfigureCamera_h(void *pane, void * /*edx*/) {
g_origConfigureCamera(pane);
const auto it = g_settings.find(pane);
if (it != g_settings.end())
ApplySettings(pane, it->second);
}
const Game::HookAutoRegister _cameraHook{
Offsets::FUN_PLAYERMODEL_CONFIGURE_CAMERA, reinterpret_cast(&ConfigureCamera_h),
reinterpret_cast(&g_origConfigureCamera)};
// 4.3.4 reconfigures whenever the pane has a model. Here the model must also
// be loaded: ConfigureCamera reads its cameras and bounds, and an unloaded
// model is configured by the ready hook when it arrives, settings included.
void Reconfigure(void *pane) {
void *model = Game::Read(pane, Offsets::OFF_SIMPLEMODELFFX_MODEL_INSTANCE);
if (model == nullptr ||
!reinterpret_cast(Offsets::FUN_MODEL_INSTANCE_LOADED)(model, 0, 0))
return;
reinterpret_cast(Offsets::FUN_PLAYERMODEL_CONFIGURE_CAMERA)(pane);
}
void *ResolvePane(void *L) {
return Game::Lua::ResolveTypedObject(L, 1, Offsets::VAR_PLAYERMODEL_LUA_TYPE_ID);
}
int __fastcall Script_SetPortraitZoom(void *L) {
void *pane = ResolvePane(L);
if (pane == nullptr)
return 0;
if (!Game::Lua::IsNumber(L, 2)) {
Game::Lua::Error(L, "Usage: SetPortraitZoom(zoom)");
return 0;
}
const auto zoom = static_cast(Game::Lua::ToNumber(L, 2));
Settings &s = g_settings[pane];
if (s.portraitZoom != zoom) {
s.portraitZoom = zoom;
Reconfigure(pane);
}
return 0;
}
int __fastcall Script_SetCamDistanceScale(void *L) {
void *pane = ResolvePane(L);
if (pane == nullptr)
return 0;
if (!Game::Lua::IsNumber(L, 2)) {
Game::Lua::Error(L, "Usage: SetCamDistanceScale(scale)");
return 0;
}
const double value = Game::Lua::ToNumber(L, 2);
if (value <= 0.0) {
Game::Lua::Error(L, "SetCamDistanceScale: Scale value must be greater than 0");
return 0;
}
const float scale = value >= 0.1 ? static_cast(value) : 0.1f;
Settings &s = g_settings[pane];
if (s.distanceScale != scale) {
s.distanceScale = scale;
Reconfigure(pane);
}
return 0;
}
int __fastcall Script_RefreshCamera(void *L) {
if (void *pane = ResolvePane(L))
Reconfigure(pane);
return 0;
}
const Game::Lua::FrameMethodEntry g_methods[] = {
{"SetPortraitZoom", &Script_SetPortraitZoom},
{"SetCamDistanceScale", &Script_SetCamDistanceScale},
{"RefreshCamera", &Script_RefreshCamera},
};
const Game::Doc::Field kZoomArgs[] = {
Game::Doc::Req("zoom", "number", "0 for the full-body camera, 1 for the portrait camera."),
};
const Game::Doc::Function kSetPortraitZoom{
"Moves the camera between the full-body view and the model's portrait view.", kZoomArgs,
{}};
const Game::Doc::Field kScaleArgs[] = {
Game::Doc::Req("scale", "number", "The camera distance multiplier; 1 is the default."),
};
const Game::Doc::Function kSetCamDistanceScale{
"Scales the camera's distance from the model.", kScaleArgs, {}};
const Game::Doc::Function kRefreshCamera{
"Configures the camera again for the current model.", {}, {}};
const Game::Doc::Method g_methodDocs[] = {
{"SetPortraitZoom", &kSetPortraitZoom},
{"SetCamDistanceScale", &kSetCamDistanceScale},
{"RefreshCamera", &kRefreshCamera},
};
void RegisterLuaFunctions() {
Game::Lua::RegisterFrameMethods(
reinterpret_cast(Offsets::VAR_PLAYERMODEL_METHOD_REGISTRY), g_methods,
static_cast(sizeof(g_methods) / sizeof(g_methods[0])), g_methodDocs,
static_cast(sizeof(g_methodDocs) / sizeof(g_methodDocs[0])));
}
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
// Frames are rebuilt on /reload and a new frame can reuse an old address.
void PrepareForReload() {
g_settings.clear();
}
const Game::ReloadAutoRegister _reloadReg{&PrepareForReload};
} // namespace
} // namespace Model::Camera