AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Finish CBallCamera

This commit is contained in:
Jack Andersen 2017-10-15 19:26:50 -10:00
parent 6d0769bba7
commit 4af2d975f4
18 changed files with 1445 additions and 955 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
DataSpec/DNACommon/Tweaks/ITweakBall.hpp
View File

@ -10,7 +10,7 @@ struct ITweakBall : ITweak
virtual float GetMaxBallTranslationAcceleration(int s) const=0;
virtual float GetBallTranslationFriction(int s) const=0;
virtual float GetBallTranslationMaxSpeed(int s) const=0;
virtual float GetBallCameraElevation() const { return 2.736f; }
virtual float GetBallCameraElevation() const=0;
virtual float GetBallCameraAnglePerSecond() const=0;
virtual const zeus::CVector3f& GetBallCameraOffset() const=0;
virtual float GetBallCameraMinSpeedDistance() const=0;
@ -32,6 +32,7 @@ struct ITweakBall : ITweak
virtual float GetBallGravity() const=0;
virtual float GetBallWaterGravity() const=0;
virtual float GetBallSlipFactor(int s) const=0;
virtual float GetConservativeDoorCameraDistance() const=0;
virtual float GetBallCameraChaseElevation() const=0;
virtual float GetBallCameraChaseDampenAngle() const=0;
virtual float GetBallCameraChaseDistance() const=0;

74
DataSpec/DNAMP1/ScriptObjects/CameraHint.hpp
View File

@ -15,57 +15,57 @@ struct CameraHint : IScriptObject
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;
Value<bool> unknown1;
Value<atUint32> unknown2;
Value<atUint32> unknown3;
Value<bool> active;
Value<atUint32> priority;
Value<atUint32> behaviour;
struct CameraHintParameters : BigYAML
{
DECL_YAML
Value<atUint32> propertyCount;
Value<bool> unknown1;
Value<bool> unknown2;
Value<bool> unknown3;
Value<bool> unknown4;
Value<bool> unknown5;
Value<bool> unknown6;
Value<bool> unknown7;
Value<bool> unknown8;
Value<bool> unknown9;
Value<bool> unknown10;
Value<bool> unknown11;
Value<bool> unknown12;
Value<bool> unknown13;
Value<bool> unknown14;
Value<bool> unknown15;
Value<bool> unknown16;
Value<bool> unknown17;
Value<bool> unknown18;
Value<bool> unknown19;
Value<bool> unknown20;
Value<bool> unknown21;
Value<bool> unknown22;
Value<bool> unknown1; // 0x1
Value<bool> chaseAllowed; // 0x2
Value<bool> boostAllowed; // 0x4
Value<bool> obscureAvoidance; // 0x8
Value<bool> volumeCollider; // 0x10
Value<bool> applyImmediately; // 0x20
Value<bool> lookAtBall; // 0x40
Value<bool> hintDistanceSelection; // 0x80
Value<bool> hintDistanceSelfPos; // 0x100
Value<bool> controlInterpolation; // 0x200
Value<bool> unknown11; // 0x400
Value<bool> unknown12; // 0x800
Value<bool> clampVelocity; // 0x1000
Value<bool> skipCinematic; // 0x2000
Value<bool> noElevationInterp; // 0x4000
Value<bool> directElevation; // 0x8000
Value<bool> overrideLookDir; // 0x10000
Value<bool> noElevationVelClamp; // 0x20000
Value<bool> calculateTransformFromPrevCam; // 0x40000
Value<bool> noSpline; // 0x80000
Value<bool> unknown21; // 0x100000
Value<bool> unknown22; // 0x200000
} cameraHintParameters;
struct BoolFloat : BigYAML
{
DECL_YAML
Value<bool> unknown1;
Value<float> unknown2;
} boolFloat1[3];
Value<bool> active;
Value<float> value;
} minDist, maxDist, backwardsDist; // 0x400000, 0x800000, 0x1000000
struct BoolVec3f : BigYAML
{
DECL_YAML
Value<bool> unknown1;
Value<atVec3f> unknown2;
} boolVec3f[2];
Value<atVec3f> unknown4;
BoolFloat boolFloat2[4];
Value<float> unknown5;
Value<bool> active;
Value<atVec3f> value;
} lookAtOffset, chaseLookAtOffset; // 0x2000000, 0x4000000
Value<atVec3f> ballToCam;
BoolFloat fov, attitudeRange, azimuthRange, anglePerSecond; // 0x8000000, 0x10000000, 0x20000000, 0x40000000
Value<float> clampVelRange;
Value<float> unknown6;
BoolFloat boolFloat3;
BoolFloat elevation; // 0x80000000
Value<float> unknown7;
Value<float> unknown8;
Value<float> unknown9;
Value<float> clampVelTime;
Value<float> controlInterpDur;
};
}
}

16
DataSpec/DNAMP1/Tweaks/CTweakBall.cpp
View File

@ -151,8 +151,8 @@ void CTweakBall::read(athena::io::IStreamReader& __dna_reader)
x168_ = __dna_reader.readFloatBig();
/* x16c_ */
x16c_ = __dna_reader.readFloatBig();
/* x170_ */
x170_ = __dna_reader.readFloatBig();
/* x170_conservativeDoorCamDistance */
x170_conservativeDoorCamDistance = __dna_reader.readFloatBig();
/* x174_ */
x174_ = __dna_reader.readFloatBig();
/* x178_ballCameraChaseElevation */
@ -371,8 +371,8 @@ void CTweakBall::write(athena::io::IStreamWriter& __dna_writer) const
__dna_writer.writeFloatBig(x168_);
/* x16c_ */
__dna_writer.writeFloatBig(x16c_);
/* x170_ */
__dna_writer.writeFloatBig(x170_);
/* x170_conservativeDoorCamDistance */
__dna_writer.writeFloatBig(x170_conservativeDoorCamDistance);
/* x174_ */
__dna_writer.writeFloatBig(x174_);
/* x178_ballCameraChaseElevation */
@ -611,8 +611,8 @@ void CTweakBall::read(athena::io::YAMLDocReader& __dna_docin)
x168_ = __dna_docin.readFloat("x168_");
/* x16c_ */
x16c_ = __dna_docin.readFloat("x16c_");
/* x170_ */
x170_ = __dna_docin.readFloat("x170_");
/* x170_conservativeDoorCamDistance */
x170_conservativeDoorCamDistance = __dna_docin.readFloat("x170_conservativeDoorCamDistance");
/* x174_ */
x174_ = __dna_docin.readFloat("x174_");
/* x178_ballCameraChaseElevation */
@ -847,8 +847,8 @@ void CTweakBall::write(athena::io::YAMLDocWriter& __dna_docout) const
__dna_docout.writeFloat("x168_", x168_);
/* x16c_ */
__dna_docout.writeFloat("x16c_", x16c_);
/* x170_ */
__dna_docout.writeFloat("x170_", x170_);
/* x170_conservativeDoorCamDistance */
__dna_docout.writeFloat("x170_conservativeDoorCamDistance", x170_conservativeDoorCamDistance);
/* x174_ */
__dna_docout.writeFloat("x174_", x174_);
/* x178_ballCameraChaseElevation */

3
DataSpec/DNAMP1/Tweaks/CTweakBall.hpp
View File

@ -66,7 +66,7 @@ struct CTweakBall final : public ITweakBall
Value<float> x164_;
Value<float> x168_;
Value<float> x16c_;
Value<float> x170_;
Value<float> x170_conservativeDoorCamDistance;
Value<float> x174_;
Value<float> x178_ballCameraChaseElevation;
Value<float> x17c_ballCameraChaseDampenAngle;
@ -155,6 +155,7 @@ struct CTweakBall final : public ITweakBall
float GetBallGravity() const { return xe4_ballGravity; }
float GetBallWaterGravity() const { return xe8_ballWaterGravity; }
float GetBallSlipFactor(int s) const { return x12c_ballSlipFactor[s]; }
float GetConservativeDoorCameraDistance() const { return x170_conservativeDoorCamDistance; }
float GetBallCameraChaseElevation() const { return x178_ballCameraChaseElevation; }
float GetBallCameraChaseDampenAngle() const { return x17c_ballCameraChaseDampenAngle; }
float GetBallCameraChaseDistance() const { return x180_ballCameraChaseDistance; }

1824
Runtime/Camera/CBallCamera.cpp
View File

File diff suppressed because it is too large Load Diff

224
Runtime/Camera/CBallCamera.hpp
View File

@ -27,16 +27,17 @@ class CCameraCollider
{
friend class CBallCamera;
float x4_radius;
zeus::CVector3f x8_;
zeus::CVector3f x14_;
zeus::CVector3f x20_;
zeus::CVector3f x2c_;
zeus::CVector3f x8_lastLocalPos;
zeus::CVector3f x14_localPos;
zeus::CVector3f x20_scaledWorldPos;
zeus::CVector3f x2c_lastWorldPos;
CCameraSpring x38_spring;
u32 x4c_occlusionCount = 0;
float x50_scale;
public:
CCameraCollider(float radius, const zeus::CVector3f& vec, const CCameraSpring& spring, float scale)
: x4_radius(radius), x8_(vec), x14_(vec), x20_(vec), x2c_(vec), x38_spring(spring), x50_scale(scale) {}
: x4_radius(radius), x8_lastLocalPos(vec), x14_localPos(vec), x20_scaledWorldPos(vec),
x2c_lastWorldPos(vec), x38_spring(spring), x50_scale(scale) {}
};
class CBallCamera : public CGameCamera
@ -44,56 +45,62 @@ class CBallCamera : public CGameCamera
public:
enum class EBallCameraState
{
Zero,
Default,
One,
Two,
Three,
Four,
Five
Chase,
Boost,
ToBall,
FromBall
};
enum class EBallCameraBehaviour
{
Zero,
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight
Default,
FreezeLookPosition, // Unused
HintBallToCam,
HintInitializePosition,
HintFixedPosition,
HintFixedTransform,
PathCameraDesiredPos, // Unused
PathCamera,
SpindleCamera
};
enum class ESplineState
{
Invalid,
Nav,
Arc
};
private:
struct SFailsafeState
{
zeus::CTransform x0_;
zeus::CTransform x30_;
zeus::CVector3f x60_;
zeus::CVector3f x6c_;
zeus::CTransform x0_playerXf;
zeus::CTransform x30_camXf;
zeus::CVector3f x60_lookPos;
zeus::CVector3f x6c_behindPos;
zeus::CVector3f x78_;
zeus::CVector3f x84_;
std::vector<zeus::CVector3f> x90_bezPoints;
zeus::CVector3f x84_playerPos;
std::vector<zeus::CVector3f> x90_splinePoints;
};
EBallCameraBehaviour x188_behaviour = EBallCameraBehaviour::Zero;
EBallCameraBehaviour x188_behaviour = EBallCameraBehaviour::Default;
bool x18c_24_ : 1;
bool x18c_25_ : 1;
bool x18c_26_ : 1;
bool x18c_27_ : 1;
bool x18c_28_ : 1;
bool x18c_29_ : 1;
bool x18c_30_ : 1;
bool x18c_31_ : 1;
bool x18d_24_ : 1;
bool x18d_25_ : 1;
bool x18d_26_ : 1;
bool x18d_27_ : 1;
bool x18d_28_ : 1;
bool x18d_29_ : 1;
bool x18d_30_ : 1;
bool x18d_31_ : 1;
bool x18e_24_ : 1;
bool x18e_25_ : 1;
bool x18c_25_chaseAllowed : 1;
bool x18c_26_boostAllowed : 1;
bool x18c_27_obscureAvoidance : 1;
bool x18c_28_volumeCollider : 1;
bool x18c_29_clampAttitude : 1;
bool x18c_30_clampAzimuth : 1;
bool x18c_31_clearLOS : 1;
bool x18d_24_prevClearLOS : 1;
bool x18d_25_avoidGeometryFull : 1;
bool x18d_26_lookAtBall : 1;
bool x18d_27_forceProcessing : 1;
bool x18d_28_obtuseDirection : 1;
bool x18d_29_noElevationInterp : 1;
bool x18d_30_directElevation : 1;
bool x18d_31_overrideLookDir : 1;
bool x18e_24_noElevationVelClamp : 1;
bool x18e_25_noSpline : 1;
bool x18e_26_ : 1;
bool x18e_27_nearbyDoorClosed : 1;
bool x18e_28_nearbyDoorClosing : 1;
@ -104,13 +111,13 @@ private:
float x1a0_elevation;
float x1a4_curAnglePerSecond;
float x1a8_targetAnglePerSecond;
float x1ac_ = 1.5533431f;
float x1b0_ = 1.5533431f;
float x1ac_attitudeRange = zeus::degToRad(89.f);
float x1b0_azimuthRange = zeus::degToRad(89.f);
zeus::CVector3f x1b4_lookAtOffset;
zeus::CVector3f x1c0_;
zeus::CVector3f x1cc_;
zeus::CVector3f x1d8_;
zeus::CTransform x1e4_;
zeus::CVector3f x1c0_lookPosAhead;
zeus::CVector3f x1cc_fixedLookPos;
zeus::CVector3f x1d8_lookPos;
zeus::CTransform x1e4_nextLookXf;
CCameraSpring x214_ballCameraSpring;
CCameraSpring x228_ballCameraCentroidSpring;
CCameraSpring x23c_ballCameraLookAtSpring;
@ -118,53 +125,53 @@ private:
std::vector<CCameraCollider> x264_smallColliders;
std::vector<CCameraCollider> x274_mediumColliders;
std::vector<CCameraCollider> x284_largeColliders;
zeus::CVector3f x294_;
zeus::CVector3f x2a0_ = zeus::CVector3f::skUp;
zeus::CVector3f x2ac_ = zeus::CVector3f::skUp;
zeus::CVector3f x2b8_ = zeus::CVector3f::skUp;
int x2c4_ = 0;
int x2c8_ = 0;
int x2cc_ = 0;
int x2d0_ = 0;
int x2d4_ = 0;
int x2d8_ = 0;
zeus::CVector3f x2dc_;
float x2e8_ = 0.f;
float x2ec_ = 0.f;
zeus::CVector3f x2f0_;
zeus::CVector3f x2fc_;
float x308_ = 0.f;
float x30c_ = 0.f;
zeus::CVector3f x310_;
zeus::CVector3f x31c_;
u32 x328_ = 0;
float x32c_ = 1.f;
float x330_ = 0.2f;
zeus::CAABox x334_ = zeus::CAABox::skNullBox;
float x34c_ = 0.f;
CMaterialList x350_ = {EMaterialTypes::Unknown};
float x358_ = 0.f;
zeus::CVector3f x35c_;
TUniqueId x368_ = kInvalidUniqueId;
u32 x36c_ = 0;
bool x370_24_ : 1;
float x374_ = 0.f;
float x378_;
zeus::CVector3f x294_dampedPos;
zeus::CVector3f x2a0_smallCentroid = zeus::CVector3f::skUp;
zeus::CVector3f x2ac_mediumCentroid = zeus::CVector3f::skUp;
zeus::CVector3f x2b8_largeCentroid = zeus::CVector3f::skUp;
int x2c4_smallCollidersObsCount = 0;
int x2c8_mediumCollidersObsCount = 0;
int x2cc_largeCollidersObsCount = 0;
int x2d0_smallColliderIt = 0;
int x2d4_mediumColliderIt = 0;
int x2d8_largeColliderIt = 0;
zeus::CVector3f x2dc_prevBallPos;
float x2e8_ballVelFlat = 0.f;
float x2ec_maxBallVel = 0.f;
zeus::CVector3f x2f0_ballDelta;
zeus::CVector3f x2fc_ballDeltaFlat;
float x308_speedFactor = 0.f;
float x30c_speedingTime = 0.f;
zeus::CVector3f x310_idealLookVec;
zeus::CVector3f x31c_predictedLookPos;
u32 x328_avoidGeomCycle = 0;
float x32c_colliderMag = 1.f;
float x330_clearColliderThreshold = 0.2f;
zeus::CAABox x334_collidersAABB = zeus::CAABox::skNullBox;
float x34c_obscuredTime = 0.f;
CMaterialList x350_obscuringMaterial = {EMaterialTypes::Unknown};
float x358_unobscureMag = 0.f;
zeus::CVector3f x35c_splineIntermediatePos;
TUniqueId x368_obscuringObjectId = kInvalidUniqueId;
ESplineState x36c_splineState = ESplineState::Invalid;
bool x370_24_reevalSplineEnd : 1;
float x374_splineCtrl = 0.f;
float x378_splineCtrlRange;
CCameraSpline x37c_camSpline;
CMaterialList x3c8_ = {EMaterialTypes::Unknown};
bool x3d0_24_ : 1;
float x3d4_ = 0.f;
float x3d8_ = 0.f;
CMaterialList x3c8_collisionExcludeList = {EMaterialTypes::Unknown};
bool x3d0_24_camBehindFloorOrWall : 1;
float x3d4_elevInterpTimer = 0.f;
float x3d8_elevInterpStart = 0.f;
TUniqueId x3dc_tooCloseActorId = kInvalidUniqueId;
float x3e0_tooCloseActorDist = 10000.f;
bool x3e4_ = false;
bool x3e4_pendingFailsafe = false;
float x3e8_ = 0.f;
float x3ec_ = 0.f;
float x3f0_ = 0.f;
float x3f4_ = 2.f;
float x3f8_ = 0.f;
float x3fc_ = 0.f;
EBallCameraState x400_state = EBallCameraState::Zero;
EBallCameraState x400_state = EBallCameraState::Default;
float x404_chaseElevation;
float x408_chaseDistance;
float x40c_chaseAnglePerSecond;
@ -175,19 +182,19 @@ private:
float x438_boostAnglePerSecond;
zeus::CVector3f x43c_boostLookAtOffset;
CCameraSpring x448_ballCameraBoostSpring;
zeus::CVector3f x45c_;
float x468_;
zeus::CVector3f x45c_overrideBallToCam;
float x468_conservativeDoorCamDistance;
TUniqueId x46c_collisionActorId = kInvalidUniqueId;
float x470_ = 0.f;
float x474_ = 0.f;
u32 x478_ = 0;
float x470_clampVelTimer = 0.f;
float x474_clampVelRange = 0.f;
u32 x478_shortMoveCount = 0;
std::unique_ptr<SFailsafeState> x47c_failsafeState;
std::unique_ptr<u32> x480_;
void SetupColliders(std::vector<CCameraCollider>& out, float xMag, float zMag, float radius, int count,
float tardis, float max, float startAngle);
void ResetSpline(CStateManager& mgr);
void BuildSpline(CStateManager& mgr);
float k, float max, float startAngle);
void BuildSplineNav(CStateManager& mgr);
void BuildSplineArc(CStateManager& mgr);
bool ShouldResetSpline(CStateManager& mgr) const;
void UpdatePlayerMovement(float dt, CStateManager& mgr);
void UpdateTransform(const zeus::CVector3f& lookDir, const zeus::CVector3f& pos, float dt, CStateManager& mgr);
@ -197,41 +204,42 @@ private:
void UpdateObjectTooCloseId(CStateManager& mgr);
void UpdateAnglePerSecond(float dt);
void UpdateUsingPathCameras(float dt, CStateManager& mgr);
zeus::CVector3f GetFixedLookTarget(const zeus::CVector3f& pos, CStateManager& mgr) const;
zeus::CVector3f GetFixedLookTarget(const zeus::CVector3f& hintToLookDir, CStateManager& mgr) const;
void UpdateUsingFixedCameras(float dt, CStateManager& mgr);
zeus::CVector3f ComputeVelocity(const zeus::CVector3f& curVel, const zeus::CVector3f& posDelta) const;
zeus::CVector3f TweenVelocity(const zeus::CVector3f& curVel, const zeus::CVector3f& newVel, float rate, float dt);
zeus::CVector3f MoveCollisionActor(const zeus::CVector3f& pos, float dt, CStateManager& mgr);
void UpdateUsingFreeLook(float dt, CStateManager& mgr);
zeus::CVector3f InterpolateCameraElevation(const zeus::CVector3f& camPos);
zeus::CVector3f CalculateCollidersCentroid(const std::vector<CCameraCollider>& colliderList, int w1) const;
zeus::CVector3f InterpolateCameraElevation(const zeus::CVector3f& camPos, float dt);
zeus::CVector3f CalculateCollidersCentroid(const std::vector<CCameraCollider>& colliderList, int numObscured) const;
zeus::CVector3f ApplyColliders();
void UpdateColliders(const zeus::CTransform& xf, std::vector<CCameraCollider>& colliderList, int& r6, int r7,
float f1, const rstl::reserved_vector<TUniqueId, 1024>& nearList, float dt,
void UpdateColliders(const zeus::CTransform& xf, std::vector<CCameraCollider>& colliderList, int& it, int count,
float tolerance, const rstl::reserved_vector<TUniqueId, 1024>& nearList, float dt,
CStateManager& mgr);
zeus::CVector3f AvoidGeometry(const zeus::CTransform& xf, const rstl::reserved_vector<TUniqueId, 1024>& nearList,
float dt, CStateManager& mgr);
zeus::CVector3f AvoidGeometryFull(const zeus::CTransform& xf, const rstl::reserved_vector<TUniqueId, 1024>& nearList,
zeus::CVector3f AvoidGeometryFull(const zeus::CTransform& xf,
const rstl::reserved_vector<TUniqueId, 1024>& nearList,
float dt, CStateManager& mgr);
zeus::CAABox CalculateCollidersBoundingBox(const std::vector<CCameraCollider>& colliderList,
CStateManager& mgr) const;
int CountObscuredColliders(const std::vector<CCameraCollider>& colliderList) const;
void UpdateCollidersDistances(std::vector<CCameraCollider>& colliderList, float f1, float f2, float f3);
void UpdateCollidersDistances(std::vector<CCameraCollider>& colliderList, float xMag, float zMag, float angOffset);
void UpdateUsingColliders(float dt, CStateManager& mgr);
void UpdateUsingSpindleCameras(float dt, CStateManager& mgr);
zeus::CVector3f ClampElevationToWater(zeus::CVector3f& pos, CStateManager& mgr) const;
void UpdateTransitionFromBallCamera(CStateManager& mgr);
void UpdateUsingTransitions(float dt, CStateManager& mgr);
zeus::CTransform UpdateCameraPositions(float dt, const zeus::CTransform& oldXf, const zeus::CTransform& newXf);
static zeus::CVector3f GetFailsafeBezierPoint(const std::vector<zeus::CVector3f>& points, float t);
static zeus::CVector3f GetFailsafeSplinePoint(const std::vector<zeus::CVector3f>& points, float t);
bool CheckFailsafeFromMorphBallState(CStateManager& mgr) const;
bool SplineIntersectTest(CMaterialList& intersectMat, CStateManager& mgr) const;
static bool IsBallNearDoor(const zeus::CVector3f& pos, CStateManager& mgr);
void ActivateFailsafe(float dt, CStateManager& mgr);
bool ConstrainElevationAndDistance(float& elevation, float& distance, float dt, CStateManager& mgr);
zeus::CVector3f FindDesiredPosition(float distance, float elevation, const zeus::CVector3f& dir,
CStateManager& mgr, bool b);
static bool DetectCollision(const zeus::CVector3f& from, const zeus::CVector3f& to, float margin,
CStateManager& mgr, bool fullTest);
static bool DetectCollision(const zeus::CVector3f& from, const zeus::CVector3f& to, float radius,
float& d, CStateManager& mgr);
void TeleportColliders(std::vector<CCameraCollider>& colliderList, const zeus::CVector3f& pos);
static bool CheckTransitionLineOfSight(const zeus::CVector3f& eyePos, const zeus::CVector3f& behindPos,
@ -254,12 +262,12 @@ public:
float GetTooCloseActorDistance() const { return x3e0_tooCloseActorDist; }
void TeleportCamera(const zeus::CVector3f& pos, CStateManager& mgr);
void TeleportCamera(const zeus::CTransform& xf, CStateManager& mgr);
const zeus::CVector3f& GetX1D8() const { return x1d8_; }
const zeus::CVector3f& GetLookPos() const { return x1d8_lookPos; }
void ResetToTweaks(CStateManager& mgr);
void UpdateLookAtPosition(float dt, CStateManager& mgr);
zeus::CTransform UpdateLookDirection(const zeus::CVector3f& dir, CStateManager& mgr);
void SetX470(float f) { x470_ = f; }
void SetX474(float f) { x474_ = f; }
void SetClampVelTimer(float f) { x470_clampVelTimer = f; }
void SetClampVelRange(float f) { x474_clampVelRange = f; }
void ApplyCameraHint(CStateManager& mgr);
void ResetPosition(CStateManager& mgr);
void DoorClosed(TUniqueId doorId);

39
Runtime/Camera/CCameraManager.cpp
View File

@ -168,12 +168,12 @@ void CCameraManager::SetSpindleCamera(TUniqueId id, CStateManager& mgr)
}
void CCameraManager::InterpolateToBallCamera(const zeus::CTransform& xf, TUniqueId camId,
const zeus::CVector3f& lookDir, float f1, float f2, float f3,
const zeus::CVector3f& lookPos, float f1, float f2, float f3,
bool b1, CStateManager& mgr)
{
if (!IsInFirstPersonCamera())
{
x88_interpCamera->SetInterpolation(xf, lookDir, f1, f2, f3, camId, b1, mgr);
x88_interpCamera->SetInterpolation(xf, lookPos, f1, f2, f3, camId, b1, mgr);
if (!ShouldBypassInterpolation())
SetCurrentCameraId(x88_interpCamera->GetUniqueId(), mgr);
}
@ -197,18 +197,19 @@ void CCameraManager::RestoreHintlessCamera(CStateManager& mgr)
x80_ballCamera->ResetToTweaks(mgr);
x80_ballCamera->UpdateLookAtPosition(0.f, mgr);
if (!mgr.GetPlayer().IsMorphBallTransitioning() &&
hint->GetHint().GetBehaviourType() != CBallCamera::EBallCameraBehaviour::Zero)
hint->GetHint().GetBehaviourType() != CBallCamera::EBallCameraBehaviour::Default)
{
if ((hint->GetHint().GetOverrideFlags() & 0x1000) != 0)
{
x80_ballCamera->SetX474(hint->GetHint().GetX4C());
x80_ballCamera->SetX470(hint->GetHint().GetX5C());
x80_ballCamera->SetClampVelRange(hint->GetHint().GetClampVelRange());
x80_ballCamera->SetClampVelTimer(hint->GetHint().GetClampVelTime());
}
else
{
x80_ballCamera->TeleportCamera(x80_ballCamera->UpdateLookDirection(camToPlayerFlat, mgr), mgr);
InterpolateToBallCamera(ballCamXf, x80_ballCamera->GetUniqueId(), x80_ballCamera->GetX1D8(),
hint->GetHint().GetX5C(), hint->GetHint().GetX4C(), hint->GetHint().GetX50(),
InterpolateToBallCamera(ballCamXf, x80_ballCamera->GetUniqueId(), x80_ballCamera->GetLookPos(),
hint->GetHint().GetClampVelTime(), hint->GetHint().GetClampVelRange(),
hint->GetHint().GetX50(),
(hint->GetHint().GetOverrideFlags() & 0x800) != 0, mgr);
}
}
@ -228,9 +229,9 @@ void CCameraManager::SkipBallCameraCinematic(CStateManager& mgr)
void CCameraManager::ApplyCameraHint(const CScriptCameraHint& hint, CStateManager& mgr)
{
if (x80_ballCamera->GetState() == CBallCamera::EBallCameraState::Four)
if (x80_ballCamera->GetState() == CBallCamera::EBallCameraState::ToBall)
{
x80_ballCamera->SetState(CBallCamera::EBallCameraState::Zero, mgr);
x80_ballCamera->SetState(CBallCamera::EBallCameraState::Default, mgr);
mgr.GetPlayer().SetCameraState(CPlayer::EPlayerCameraState::Ball, mgr);
}
@ -246,11 +247,11 @@ void CCameraManager::ApplyCameraHint(const CScriptCameraHint& hint, CStateManage
switch (hint.GetHint().GetBehaviourType())
{
case CBallCamera::EBallCameraBehaviour::Six:
case CBallCamera::EBallCameraBehaviour::Seven:
case CBallCamera::EBallCameraBehaviour::PathCameraDesiredPos:
case CBallCamera::EBallCameraBehaviour::PathCamera:
SetPathCamera(hint.GetDelegatedCamera(), mgr);
break;
case CBallCamera::EBallCameraBehaviour::Eight:
case CBallCamera::EBallCameraBehaviour::SpindleCamera:
SetSpindleCamera(hint.GetDelegatedCamera(), mgr);
break;
default:
@ -265,11 +266,11 @@ void CCameraManager::ApplyCameraHint(const CScriptCameraHint& hint, CStateManage
x80_ballCamera->UpdateLookAtPosition(0.f, mgr);
if ((hint.GetHint().GetOverrideFlags() & 0x20) == 0 &&
(hint.GetHint().GetBehaviourType() != CBallCamera::EBallCameraBehaviour::Zero ||
(oldHint && oldHint->GetHint().GetBehaviourType() != CBallCamera::EBallCameraBehaviour::Zero)))
(hint.GetHint().GetBehaviourType() != CBallCamera::EBallCameraBehaviour::Default ||
(oldHint && oldHint->GetHint().GetBehaviourType() != CBallCamera::EBallCameraBehaviour::Default)))
{
InterpolateToBallCamera(camXf, x80_ballCamera->GetUniqueId(), x80_ballCamera->GetX1D8(),
hint.GetHint().GetX58(), hint.GetHint().GetX4C(), hint.GetHint().GetX50(),
InterpolateToBallCamera(camXf, x80_ballCamera->GetUniqueId(), x80_ballCamera->GetLookPos(),
hint.GetHint().GetX58(), hint.GetHint().GetClampVelRange(), hint.GetHint().GetX50(),
(hint.GetHint().GetOverrideFlags() & 0x400) != 0, mgr);
}
}
@ -478,12 +479,12 @@ void CCameraManager::UpdateCameraHints(float, CStateManager& mgr)
}
else if (xa6_camHintId != bestHint->GetUniqueId())
{
if (bestHint->GetHint().GetBehaviourType() == CBallCamera::EBallCameraBehaviour::Three)
if (bestHint->GetHint().GetBehaviourType() == CBallCamera::EBallCameraBehaviour::HintInitializePosition)
{
if ((bestHint->GetHint().GetOverrideFlags() & 0x20) != 0)
{
x80_ballCamera->TeleportCamera(
zeus::lookAt(bestHint->GetTranslation(), x80_ballCamera->GetX1D8()), mgr);
zeus::lookAt(bestHint->GetTranslation(), x80_ballCamera->GetLookPos()), mgr);
}
DeleteCameraHint(bestHint->GetUniqueId(), mgr);
if ((bestHint->GetHint().GetOverrideFlags() & 0x2000) != 0)
@ -659,7 +660,7 @@ void CCameraManager::SetupBallCamera(CStateManager& mgr)
{
if (TCastToPtr<CScriptCameraHint> hint = mgr.ObjectById(xa6_camHintId))
{
if (hint->GetHint().GetBehaviourType() == CBallCamera::EBallCameraBehaviour::Three)
if (hint->GetHint().GetBehaviourType() == CBallCamera::EBallCameraBehaviour::HintInitializePosition)
{
if ((hint->GetHint().GetOverrideFlags() & 0x20) != 0)
x80_ballCamera->TeleportCamera(hint->GetTransform(), mgr);

2
Runtime/Camera/CCameraManager.hpp
View File

@ -76,7 +76,7 @@ class CCameraManager
void SetPathCamera(TUniqueId id, CStateManager& mgr);
void SetSpindleCamera(TUniqueId id, CStateManager& mgr);
void RestoreHintlessCamera(CStateManager& mgr);
void InterpolateToBallCamera(const zeus::CTransform& xf, TUniqueId camId, const zeus::CVector3f& lookDir,
void InterpolateToBallCamera(const zeus::CTransform& xf, TUniqueId camId, const zeus::CVector3f& lookPos,
float f1, float f2, float f3, bool b1, CStateManager& mgr);
static constexpr bool ShouldBypassInterpolation() { return false; }
void SkipBallCameraCinematic(CStateManager& mgr);

2
Runtime/Camera/CInterpolationCamera.cpp
View File

@ -44,7 +44,7 @@ void CInterpolationCamera::Think(float, CStateManager& mgr)
}
void CInterpolationCamera::SetInterpolation(const zeus::CTransform& xf, const zeus::CVector3f& lookDir,
void CInterpolationCamera::SetInterpolation(const zeus::CTransform& xf, const zeus::CVector3f& lookPos,
float f1, float f2, float f3, TUniqueId camId, bool b1, CStateManager& mgr)
{

2
Runtime/Camera/CInterpolationCamera.hpp
View File

@ -16,7 +16,7 @@ public:
void Render(const CStateManager&) const;
void Reset(const zeus::CTransform&, CStateManager& mgr);
void Think(float, CStateManager &);
void SetInterpolation(const zeus::CTransform& xf, const zeus::CVector3f& lookDir,
void SetInterpolation(const zeus::CTransform& xf, const zeus::CVector3f& lookPos,
float f1, float f2, float f3, TUniqueId camId, bool b1, CStateManager& mgr);
};

18
Runtime/Graphics/Shaders/CModelShadersHLSL.cpp
View File

@ -82,16 +82,16 @@ static const char* LightingShadowHLSL =
"{\n"
" float4 ret = ambient;\n"
" \n"
" float3 delta = mvPosIn.xyz - lights[i].pos.xyz;\n"
" float3 delta = mvPosIn.xyz - lights[0].pos.xyz;\n"
" float dist = length(delta);\n"
" float angDot = saturate(dot(normalize(delta), lights[i].dir.xyz));\n"
" float att = 1.0 / (lights[i].linAtt[2] * dist * dist +\n"
" lights[i].linAtt[1] * dist +\n"
" lights[i].linAtt[0]);\n"
" float angAtt = lights[i].angAtt[2] * angDot * angDot +\n"
" lights[i].angAtt[1] * angDot +\n"
" lights[i].angAtt[0];\n"
" ret += lights[i].color * saturate(angAtt) * att * saturate(dot(normalize(-delta), mvNormIn.xyz)) *\n"
" float angDot = saturate(dot(normalize(delta), lights[0].dir.xyz));\n"
" float att = 1.0 / (lights[0].linAtt[2] * dist * dist +\n"
" lights[0].linAtt[1] * dist +\n"
" lights[0].linAtt[0]);\n"
" float angAtt = lights[0].angAtt[2] * angDot * angDot +\n"
" lights[0].angAtt[1] * angDot +\n"
" lights[0].angAtt[0];\n"
" ret += lights[0].color * saturate(angAtt) * att * saturate(dot(normalize(-delta), mvNormIn.xyz)) *\n"
" extTex0.Sample(clampSamp, vtf.extTcgs[0]).r;\n"
" \n"
" for (int i=1 ; i<" _XSTR(URDE_MAX_LIGHTS) " ; ++i)\n"

18
Runtime/Graphics/Shaders/CModelShadersMetal.cpp
View File

@ -83,16 +83,16 @@ static const char* LightingShadowMetal =
"{\n"
" float4 ret = lu.ambient;\n"
" \n"
" float3 delta = mvPosIn.xyz - lu.lights[i].pos.xyz;\n"
" float3 delta = mvPosIn.xyz - lu.lights[0].pos.xyz;\n"
" float dist = length(delta);\n"
" float angDot = saturate(dot(normalize(delta), lu.lights[i].dir.xyz));\n"
" float att = 1.0 / (lu.lights[i].linAtt[2] * dist * dist +\n"
" lu.lights[i].linAtt[1] * dist +\n"
" lu.lights[i].linAtt[0]);\n"
" float angAtt = lu.lights[i].angAtt[2] * angDot * angDot +\n"
" lu.lights[i].angAtt[1] * angDot +\n"
" lu.lights[i].angAtt[0];\n"
" ret += lu.lights[i].color * saturate(angAtt) * att * saturate(dot(normalize(-delta), mvNormIn.xyz)) *\n"
" float angDot = saturate(dot(normalize(delta), lu.lights[0].dir.xyz));\n"
" float att = 1.0 / (lu.lights[0].linAtt[2] * dist * dist +\n"
" lu.lights[0].linAtt[1] * dist +\n"
" lu.lights[0].linAtt[0]);\n"
" float angAtt = lu.lights[0].angAtt[2] * angDot * angDot +\n"
" lu.lights[0].angAtt[1] * angDot +\n"
" lu.lights[0].angAtt[0];\n"
" ret += lu.lights[0].color * saturate(angAtt) * att * saturate(dot(normalize(-delta), mvNormIn.xyz)) *\n"
" extTex0.sample(clampSamp, vtf.extTcgs0);\n"
" \n"
" for (int i=1 ; i<" _XSTR(URDE_MAX_LIGHTS) " ; ++i)\n"

10
Runtime/World/CPlayer.cpp
View File

@ -189,11 +189,11 @@ void CPlayer::TransitionToMorphBallState(float dt, CStateManager& mgr)
if (!mgr.GetCameraManager()->HasBallCameraInitialPositionHint(mgr))
{
mgr.GetCameraManager()->SetupBallCamera(mgr);
ballCam->SetState(CBallCamera::EBallCameraState::Four, mgr);
ballCam->SetState(CBallCamera::EBallCameraState::ToBall, mgr);
}
else
{
ballCam->SetState(CBallCamera::EBallCameraState::Zero, mgr);
ballCam->SetState(CBallCamera::EBallCameraState::Default, mgr);
SetCameraState(EPlayerCameraState::Ball, mgr);
zeus::CTransform newXf = mgr.GetCameraManager()->GetFirstPersonCamera()->GetTransform();
ballCam->SetTransform(newXf);
@ -304,7 +304,7 @@ void CPlayer::TransitionFromMorphBallState(CStateManager& mgr)
ForceGunOrientation(x34_transform, mgr);
DrawGun(mgr);
ballCam->SetState(CBallCamera::EBallCameraState::Five, mgr);
ballCam->SetState(CBallCamera::EBallCameraState::FromBall, mgr);
ClearForcesAndTorques();
SetAngularVelocityWR(zeus::CAxisAngle::sIdentity);
AddMaterial(EMaterialTypes::GroundCollider, mgr);
@ -6173,7 +6173,7 @@ void CPlayer::LeaveMorphBallState(CStateManager& mgr)
x3f0_vertFreeLookAngleVel = 0.f;
x768_morphball->LeaveMorphBallState(mgr);
mgr.GetCameraManager()->SetPlayerCamera(mgr, mgr.GetCameraManager()->GetFirstPersonCamera()->GetUniqueId());
mgr.GetCameraManager()->GetBallCamera()->SetState(CBallCamera::EBallCameraState::Zero, mgr);
mgr.GetCameraManager()->GetBallCamera()->SetState(CBallCamera::EBallCameraState::Default, mgr);
SetCameraState(EPlayerCameraState::FirstPerson, mgr);
mgr.GetCameraManager()->GetFirstPersonCamera()->DeferBallTransitionProcessing();
mgr.GetCameraManager()->GetFirstPersonCamera()->Think(0.f, mgr);
@ -6205,7 +6205,7 @@ void CPlayer::EnterMorphBallState(CStateManager& mgr)
void CPlayer::ActivateMorphBallCamera(CStateManager& mgr)
{
SetCameraState(EPlayerCameraState::Ball, mgr);
mgr.GetCameraManager()->GetBallCamera()->SetState(CBallCamera::EBallCameraState::Zero, mgr);
mgr.GetCameraManager()->GetBallCamera()->SetState(CBallCamera::EBallCameraState::Default, mgr);
}
void CPlayer::UpdateCinematicState(CStateManager& mgr)

14
Runtime/World/CScriptCameraHint.cpp
View File

@ -8,13 +8,17 @@ namespace urde
CScriptCameraHint::CScriptCameraHint(TUniqueId uid, const std::string& name, const CEntityInfo& info,
const zeus::CTransform& xf, bool active, s32 priority,
CBallCamera::EBallCameraBehaviour behaviour, s32 overrideFlags, float f1,
float f2, float f3, const zeus::CVector3f& r6, const zeus::CVector3f& r7,
const zeus::CVector3f& r8, float f4, float f5, float f6, float f7,
float f8, float f9, float f10, float f11, float f12, float f13)
CBallCamera::EBallCameraBehaviour behaviour, u32 overrideFlags, float minDist,
float maxDist, float backwardsDist, const zeus::CVector3f& lookAtOffset,
const zeus::CVector3f& chaseLookAtOffset, const zeus::CVector3f& ballToCam,
float fov, float attitudeRange, float azimuthRange, float anglePerSecond,
float clampVelRange, float f9, float elevation, float f11,
float clampVelTime, float controlInterpDur)
: CActor(uid, active, name, info, xf, CModelData::CModelDataNull(), CMaterialList(EMaterialTypes::Unknown),
CActorParameters::None(), kInvalidUniqueId), xe8_priority(priority),
xec_hint(overrideFlags, behaviour, f1, f2, f3, r6, r7, r8, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13),
xec_hint(overrideFlags, behaviour, minDist, maxDist, backwardsDist, lookAtOffset, chaseLookAtOffset, ballToCam,
fov, attitudeRange, azimuthRange, anglePerSecond, clampVelRange, f9, elevation, f11, clampVelTime,
controlInterpDur),
x168_origXf(xf)
{
}

73
Runtime/World/CScriptCameraHint.hpp
View File

@ -9,39 +9,55 @@ namespace urde
class CCameraHint
{
s32 x4_overrideFlags;
u32 x4_overrideFlags;
CBallCamera::EBallCameraBehaviour x8_behaviour;
float xc_f1;
float x10_f2;
float x14_f3;
zeus::CVector3f x18_r6;
zeus::CVector3f x24_r7;
zeus::CVector3f x30_r8;
float x3c_f4;
float x40_f5;
float x44_f6;
float x48_f7;
float x4c_f8;
float xc_minDist;
float x10_maxDist;
float x14_backwardsDist;
zeus::CVector3f x18_lookAtOffset;
zeus::CVector3f x24_chaseLookAtOffset;
zeus::CVector3f x30_ballToCam;
float x3c_fov;
float x40_attitudeRange;
float x44_azimuthRange;
float x48_anglePerSecond;
float x4c_clampVelRange;
float x50_f9;
float x54_f10;
float x54_elevation;
float x58_f11;
float x5c_f12;
float x60_f13;
float x5c_clampVelTime;
float x60_controlInterpDur;
public:
CCameraHint(s32 overrideFlags, CBallCamera::EBallCameraBehaviour behaviour, float f1, float f2, float f3,
const zeus::CVector3f& r6, const zeus::CVector3f& r7, const zeus::CVector3f& r8, float f4,
float f5, float f6, float f7, float f8, float f9, float f10, float f11, float f12, float f13)
: x4_overrideFlags(overrideFlags), x8_behaviour(behaviour), xc_f1(f1), x10_f2(f2), x14_f3(f3), x18_r6(r6),
x24_r7(r7), x30_r8(r8), x3c_f4(f4), x40_f5(f5), x44_f6(f6), x48_f7(f7), x4c_f8(f8), x50_f9(f9), x54_f10(f10),
x58_f11(f11), x5c_f12(f12), x60_f13(f13) {}
CCameraHint(u32 overrideFlags, CBallCamera::EBallCameraBehaviour behaviour, float minDist, float maxDist,
float backwardsDist, const zeus::CVector3f& lookAtOffset, const zeus::CVector3f& chaseLookAtOffset,
const zeus::CVector3f& ballToCam, float fov, float attitudeRange, float azimuthRange,
float anglePerSecond, float clampVelRange, float f9, float elevation, float f11,
float clampVelTime, float controlInterpDur)
: x4_overrideFlags(overrideFlags), x8_behaviour(behaviour), xc_minDist(minDist), x10_maxDist(maxDist),
x14_backwardsDist(backwardsDist), x18_lookAtOffset(lookAtOffset), x24_chaseLookAtOffset(chaseLookAtOffset),
x30_ballToCam(ballToCam), x3c_fov(fov), x40_attitudeRange(attitudeRange), x44_azimuthRange(azimuthRange),
x48_anglePerSecond(anglePerSecond), x4c_clampVelRange(clampVelRange), x50_f9(f9), x54_elevation(elevation),
x58_f11(f11), x5c_clampVelTime(clampVelTime), x60_controlInterpDur(controlInterpDur) {}
s32 GetOverrideFlags() const { return x4_overrideFlags; }
u32 GetOverrideFlags() const { return x4_overrideFlags; }
CBallCamera::EBallCameraBehaviour GetBehaviourType() const { return x8_behaviour; }
float GetX4C() const { return x4c_f8; }
float GetMinDist() const { return xc_minDist; }
float GetMaxDist() const { return x10_maxDist; }
float GetBackwardsDist() const { return x14_backwardsDist; }
const zeus::CVector3f& GetLookAtOffset() const { return x18_lookAtOffset; }
const zeus::CVector3f& GetChaseLookAtOffset() const { return x24_chaseLookAtOffset; }
const zeus::CVector3f& GetBallToCam() const { return x30_ballToCam; }
float GetFov() const { return x3c_fov; }
float GetAttitudeRange() const { return x40_attitudeRange; }
float GetAzimuthRange() const { return x44_azimuthRange; }
float GetAnglePerSecond() const { return x48_anglePerSecond; }
float GetClampVelRange() const { return x4c_clampVelRange; }
float GetX50() const { return x50_f9; }
float GetElevation() const { return x54_elevation; }
float GetX58() const { return x58_f11; }
float GetX5C() const { return x5c_f12; }
float GetClampVelTime() const { return x5c_clampVelTime; }
float GetControlInterpDur() const { return x60_controlInterpDur; }
};
class CScriptCameraHint : public CActor
@ -57,10 +73,11 @@ class CScriptCameraHint : public CActor
void RemoveHelper(TUniqueId id);
public:
CScriptCameraHint(TUniqueId, const std::string& name, const CEntityInfo& info, const zeus::CTransform& xf,
bool active, s32 priority, CBallCamera::EBallCameraBehaviour behaviour, s32 overrideFlags,
float f1, float f2, float f3, const zeus::CVector3f& r6, const zeus::CVector3f& r7,
const zeus::CVector3f& r8, float f4, float f5, float f6, float f7, float f8, float f9, float f10,
float f11, float f12, float f13);
bool active, s32 priority, CBallCamera::EBallCameraBehaviour behaviour, u32 overrideFlags,
float minDist, float maxDist, float backwardsDist, const zeus::CVector3f& lookAtOffset,
const zeus::CVector3f& chaseLookAtOffset, const zeus::CVector3f& ballToCam, float fov,
float attitudeRange, float azimuthRange, float anglePerSecond, float clampVelRange, float f9,
float elevation, float f11, float clampVelTime, float controlInterpDur);
void Accept(IVisitor& visitor);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr);

8
Runtime/World/CScriptDoor.cpp
View File

@ -34,7 +34,7 @@ CScriptDoor::CScriptDoor(TUniqueId uid, const std::string& name, const CEntityIn
{
x2a8_29_ballDoor = ballDoor;
x2a8_25_ = open;
x2a8_26_ = open;
x2a8_26_useConservativeCameraDistance = open;
x2a8_28_ = b2;
x2a8_27_ = true;
x264_ = GetBoundingBox();
@ -70,7 +70,7 @@ void CScriptDoor::Think(float dt, CStateManager& mgr)
if (!GetActive())
return;
if (!x2a8_26_)
if (!x2a8_26_useConservativeCameraDistance)
{
if (x25c_ < 0.5f)
x25c_ += dt;
@ -86,9 +86,9 @@ void CScriptDoor::AddToRenderer(const zeus::CFrustum& /*frustum*/, CStateManager
/* ORIGINAL 0-00 OFFSET: 8007E0BC */
void CScriptDoor::ForceClosed(CStateManager & mgr)
{
if (x2a8_26_)
if (x2a8_26_useConservativeCameraDistance)
{
x2a8_26_ = false;
x2a8_26_useConservativeCameraDistance = false;
x2a8_25_ = false;
mgr.GetCameraManager()->GetBallCamera()->DoorClosing(x8_uid);

2
Runtime/World/CScriptDoor.hpp
View File

@ -42,7 +42,7 @@ public:
{
bool x2a8_24_ : 1;
bool x2a8_25_ : 1;
bool x2a8_26_ : 1;
bool x2a8_26_useConservativeCameraDistance : 1;
bool x2a8_27_ : 1;
bool x2a8_28_ : 1;
bool x2a8_29_ballDoor : 1;

64
Runtime/World/ScriptLoader.cpp
View File

@ -845,41 +845,43 @@ CEntity* ScriptLoader::LoadCameraHint(CStateManager& mgr, CInputStream& in, int
SActorHead head = LoadActorHead(in, mgr);
bool active = in.readBool();
u32 w1 = in.readUint32Big();
u32 prio = in.readUint32Big();
auto behaviour = CBallCamera::EBallCameraBehaviour(in.readUint32Big());
u32 pf = LoadParameterFlags(in);
pf |= in.readBool() << 6;
float f1 = in.readFloatBig();
pf |= in.readBool() << 7;
float f2 = in.readFloatBig();
pf |= in.readBool() << 8;
float f3 = in.readFloatBig();
zeus::CVector3f vec1;
vec1.readBig(in);
pf |= in.readBool() << 9;
zeus::CVector3f vec2;
vec2.readBig(in);
zeus::CVector3f vec3;
vec3.readBig(in);
pf |= in.readBool() << 10;
float f4 = in.readFloatBig();
pf |= in.readBool() << 11;
float f5 = in.readFloatBig();
pf |= in.readBool() << 12;
float f6 = in.readFloatBig();
pf |= in.readBool() << 13;
float f7 = in.readFloatBig();
float f8 = in.readFloatBig();
u32 overrideFlags = LoadParameterFlags(in);
overrideFlags |= in.readBool() << 22;
float minDist = in.readFloatBig();
overrideFlags |= in.readBool() << 23;
float maxDist = in.readFloatBig();
overrideFlags |= in.readBool() << 24;
float backwardsDist = in.readFloatBig();
overrideFlags |= in.readBool() << 25;
zeus::CVector3f lookAtOffset;
lookAtOffset.readBig(in);
overrideFlags |= in.readBool() << 26;
zeus::CVector3f chaseLookAtOffset;
chaseLookAtOffset.readBig(in);
zeus::CVector3f ballToCam;
ballToCam.readBig(in);
overrideFlags |= in.readBool() << 27;
float fov = in.readFloatBig();
overrideFlags |= in.readBool() << 28;
float attitudeRange = in.readFloatBig();
overrideFlags |= in.readBool() << 29;
float azimuthRange = in.readFloatBig();
overrideFlags |= in.readBool() << 30;
float anglePerSecond = in.readFloatBig();
float clampVelRange = in.readFloatBig();
float f9 = in.readFloatBig();
pf |= in.readBool() << 14;
float f10 = in.readFloatBig();
overrideFlags |= in.readBool() << 31;
float elevation = in.readFloatBig();
float f11 = in.readFloatBig();
float f12 = in.readFloatBig();
float f13 = in.readFloatBig();
float clampVelTime = in.readFloatBig();
float controlInterpDur = in.readFloatBig();
return new CScriptCameraHint(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, active, w1,
behaviour, pf, f1, f2, f3, vec1, vec2, vec3, f4, f5, f6, f7, f8, f9, f10,
f11, f12, f13);
return new CScriptCameraHint(mgr.AllocateUniqueId(), head.x0_name, info, head.x10_transform, active, prio,
behaviour, overrideFlags, minDist, maxDist, backwardsDist, lookAtOffset,
chaseLookAtOffset, ballToCam, fov, attitudeRange, azimuthRange, anglePerSecond,
clampVelRange, f9, elevation, f11, clampVelTime, controlInterpDur);
}
CEntity* ScriptLoader::LoadPickup(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info)