TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-15 08:34:40 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

afx camera membervar cleanups

Browse source
This commit is contained in:
Azaezel 2018-03-30 02:51:44 -05:00
parent 47fc9325d1
commit e1c30fea37
2 changed files with 144 additions and 144 deletions
Download patch file Download diff file Expand all files Collapse all files

258
Engine/source/afx/afxCamera.cpp
View file

@ -99,11 +99,11 @@ afxCamera::afxCamera()
{ {
mNetFlags.clear(Ghostable); mNetFlags.clear(Ghostable);
mTypeMask |= CameraObjectType; mTypeMask |= CameraObjectType;
delta.pos = Point3F(0,0,100); mDelta.pos = Point3F(0,0,100);
delta.rot = Point3F(0,0,0); mDelta.rot = Point3F(0,0,0);
delta.posVec = delta.rotVec = VectorF(0,0,0); mDelta.posVec = mDelta.rotVec = VectorF(0,0,0);
mObjToWorld.setColumn(3,delta.pos); mObjToWorld.setColumn(3, mDelta.pos);
mRot = delta.rot; mRot = mDelta.rot;
mMinOrbitDist = 0; mMinOrbitDist = 0;
mMaxOrbitDist = 0; mMaxOrbitDist = 0;
@ -111,19 +111,19 @@ afxCamera::afxCamera()
mOrbitObject = NULL; mOrbitObject = NULL;
mPosition.set(0.f, 0.f, 0.f); mPosition.set(0.f, 0.f, 0.f);
mObservingClientObject = false; mObservingClientObject = false;
mode = FlyMode; mMode = FlyMode;
cam_subject = NULL; mCam_subject = NULL;
coi_offset.set(0, 0, 2); mCoi_offset.set(0, 0, 2);
cam_offset.set(0, 0, 0); mCam_offset.set(0, 0, 0);
cam_distance = 0.0f; mCam_distance = 0.0f;
cam_angle = 0.0f; mCam_angle = 0.0f;
cam_dirty = false; mCam_dirty = false;
flymode_saved = false; mFlymode_saved = false;
third_person_snap_s = 1; mThird_person_snap_s = 1;
third_person_snap_c = 1; mThird_person_snap_c = 1;
flymode_saved_pos.zero(); mFlymode_saved_pos.zero();
mDamageState = Disabled; mDamageState = Disabled;
} }
@ -136,7 +136,7 @@ afxCamera::~afxCamera()
void afxCamera::cam_update(F32 dt, bool on_server) void afxCamera::cam_update(F32 dt, bool on_server)
{ {
if (mode == ThirdPersonMode && cam_subject) if (mMode == ThirdPersonMode && mCam_subject)
cam_update_3pov(dt, on_server); cam_update_3pov(dt, on_server);
} }
@ -176,9 +176,9 @@ Point3F &afxCamera::getPosition()
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void afxCamera::setFlyMode() void afxCamera::setFlyMode()
{ {
mode = FlyMode; mMode = FlyMode;
if (flymode_saved) if (mFlymode_saved)
snapToPosition(flymode_saved_pos); snapToPosition(mFlymode_saved_pos);
if (bool(mOrbitObject)) if (bool(mOrbitObject))
{ {
@ -202,11 +202,11 @@ void afxCamera::setOrbitMode(GameBase *obj, Point3F &pos, AngAxisF &rot, F32 min
processAfter(mOrbitObject); processAfter(mOrbitObject);
deleteNotify(mOrbitObject); deleteNotify(mOrbitObject);
mOrbitObject->getWorldBox().getCenter(&mPosition); mOrbitObject->getWorldBox().getCenter(&mPosition);
mode = OrbitObjectMode; mMode = OrbitObjectMode;
} }
else else
{ {
mode = OrbitPointMode; mMode = OrbitPointMode;
mPosition = pos; mPosition = pos;
} }
@ -278,14 +278,14 @@ void afxCamera::snapToPosition(const Point3F& tPos)
{ {
MatrixF transMat; MatrixF transMat;
if (cam_subject) if (mCam_subject)
{ {
// get the subject's transform // get the subject's transform
MatrixF objToWorld = cam_subject->getRenderTransform(); MatrixF objToWorld = mCam_subject->getRenderTransform();
// transform the center-of-interest to world-space // transform the center-of-interest to world-space
Point3F objPos; Point3F objPos;
objToWorld.mulP(coi_offset, &objPos); objToWorld.mulP(mCoi_offset, &objPos);
// find normalized direction vector looking from camera to coi // find normalized direction vector looking from camera to coi
VectorF dirVec = objPos - tPos; VectorF dirVec = objPos - tPos;
@ -308,31 +308,31 @@ void afxCamera::snapToPosition(const Point3F& tPos)
void afxCamera::setCameraSubject(SceneObject* new_subject) void afxCamera::setCameraSubject(SceneObject* new_subject)
{ {
// cleanup any existing chase subject // cleanup any existing chase subject
if (cam_subject) if (mCam_subject)
{ {
if (dynamic_cast<GameBase*>(cam_subject)) if (dynamic_cast<GameBase*>(mCam_subject))
clearProcessAfter(); clearProcessAfter();
clearNotify(cam_subject); clearNotify(mCam_subject);
} }
cam_subject = new_subject; mCam_subject = new_subject;
// set associations with new chase subject // set associations with new chase subject
if (cam_subject) if (mCam_subject)
{ {
if (dynamic_cast<GameBase*>(cam_subject)) if (dynamic_cast<GameBase*>(mCam_subject))
processAfter((GameBase*)cam_subject); processAfter((GameBase*)mCam_subject);
deleteNotify(cam_subject); deleteNotify(mCam_subject);
} }
mode = (cam_subject) ? ThirdPersonMode : FlyMode; mMode = (mCam_subject) ? ThirdPersonMode : FlyMode;
setMaskBits(SubjectMask); setMaskBits(SubjectMask);
} }
void afxCamera::setThirdPersonOffset(const Point3F& offset) void afxCamera::setThirdPersonOffset(const Point3F& offset)
{ {
// new method // new method
if (cam_distance > 0.0f) if (mCam_distance > 0.0f)
{ {
if (isClientObject()) if (isClientObject())
{ {
@ -342,25 +342,25 @@ void afxCamera::setThirdPersonOffset(const Point3F& offset)
// this auto switches to/from first person // this auto switches to/from first person
if (conn->isFirstPerson()) if (conn->isFirstPerson())
{ {
if (cam_distance >= 1.0f) if (mCam_distance >= 1.0f)
conn->setFirstPerson(false); conn->setFirstPerson(false);
} }
else else
{ {
if (cam_distance < 1.0f) if (mCam_distance < 1.0f)
conn->setFirstPerson(true); conn->setFirstPerson(true);
} }
} }
} }
cam_offset = offset; mCam_offset = offset;
cam_dirty = true; mCam_dirty = true;
return; return;
} }
// old backwards-compatible method // old backwards-compatible method
if (offset.y != cam_offset.y && isClientObject()) if (offset.y != mCam_offset.y && isClientObject())
{ {
GameConnection* conn = GameConnection::getConnectionToServer(); GameConnection* conn = GameConnection::getConnectionToServer();
if (conn) if (conn)
@ -379,62 +379,62 @@ void afxCamera::setThirdPersonOffset(const Point3F& offset)
} }
} }
cam_offset = offset; mCam_offset = offset;
cam_dirty = true; mCam_dirty = true;
} }
void afxCamera::setThirdPersonOffset(const Point3F& offset, const Point3F& coi_offset) void afxCamera::setThirdPersonOffset(const Point3F& offset, const Point3F& coi_offset)
{ {
this->coi_offset = coi_offset; mCoi_offset = coi_offset;
setThirdPersonOffset(offset); setThirdPersonOffset(offset);
} }
void afxCamera::setThirdPersonDistance(F32 distance) void afxCamera::setThirdPersonDistance(F32 distance)
{ {
cam_distance = distance; mCam_distance = distance;
cam_dirty = true; mCam_dirty = true;
} }
F32 afxCamera::getThirdPersonDistance() F32 afxCamera::getThirdPersonDistance()
{ {
return cam_distance; return mCam_distance;
} }
void afxCamera::setThirdPersonAngle(F32 angle) void afxCamera::setThirdPersonAngle(F32 angle)
{ {
cam_angle = angle; mCam_angle = angle;
cam_dirty = true; mCam_dirty = true;
} }
F32 afxCamera::getThirdPersonAngle() F32 afxCamera::getThirdPersonAngle()
{ {
return cam_angle; return mCam_angle;
} }
void afxCamera::setThirdPersonMode() void afxCamera::setThirdPersonMode()
{ {
mode = ThirdPersonMode; mMode = ThirdPersonMode;
flymode_saved_pos = getPosition(); mFlymode_saved_pos = getPosition();
flymode_saved = true; mFlymode_saved = true;
cam_dirty = true; mCam_dirty = true;
third_person_snap_s++; mThird_person_snap_s++;
} }
void afxCamera::setThirdPersonSnap() void afxCamera::setThirdPersonSnap()
{ {
if (mode == ThirdPersonMode) if (mMode == ThirdPersonMode)
third_person_snap_s += 2; mThird_person_snap_s += 2;
} }
void afxCamera::setThirdPersonSnapClient() void afxCamera::setThirdPersonSnapClient()
{ {
if (mode == ThirdPersonMode) if (mMode == ThirdPersonMode)
third_person_snap_c++; mThird_person_snap_c++;
} }
const char* afxCamera::getMode() const char* afxCamera::getMode()
{ {
switch (mode) switch (mMode)
{ {
case ThirdPersonMode: case ThirdPersonMode:
return "ThirdPerson"; return "ThirdPerson";
@ -593,17 +593,17 @@ void afxCamera::cam_update_3pov(F32 dt, bool on_server)
{ {
Point3F goal_pos; Point3F goal_pos;
Point3F curr_pos = getRenderPosition(); Point3F curr_pos = getRenderPosition();
MatrixF xfm = cam_subject->getRenderTransform(); MatrixF xfm = mCam_subject->getRenderTransform();
Point3F coi = cam_subject->getRenderPosition() + coi_offset; Point3F coi = mCam_subject->getRenderPosition() + mCoi_offset;
// for player subjects, pitch is adjusted // for player subjects, pitch is adjusted
Player* player_subj = dynamic_cast<Player*>(cam_subject); Player* player_subj = dynamic_cast<Player*>(mCam_subject);
if (player_subj) if (player_subj)
{ {
if (cam_distance > 0.0f) if (mCam_distance > 0.0f)
{ {
// rotate xfm by amount of cam_angle // rotate xfm by amount of cam_angle
F32 look_yaw = player_subj->getHeadRotation().z + mDegToRad(-cam_angle); F32 look_yaw = player_subj->getHeadRotation().z + mDegToRad(-mCam_angle);
MatrixF look_yaw_mtx(EulerF(0,0,look_yaw)); MatrixF look_yaw_mtx(EulerF(0,0,look_yaw));
xfm.mul(look_yaw_mtx); xfm.mul(look_yaw_mtx);
@ -612,9 +612,9 @@ void afxCamera::cam_update_3pov(F32 dt, bool on_server)
MatrixF head_pitch_mtx(EulerF(head_pitch,0,0)); MatrixF head_pitch_mtx(EulerF(head_pitch,0,0));
xfm.mul(head_pitch_mtx); xfm.mul(head_pitch_mtx);
VectorF behind_vec(0, -cam_distance, 0); VectorF behind_vec(0, -mCam_distance, 0);
xfm.mulP(behind_vec, &goal_pos); xfm.mulP(behind_vec, &goal_pos);
goal_pos += cam_offset; goal_pos += mCam_offset;
} }
else // old backwards-compatible method else // old backwards-compatible method
{ {
@ -623,15 +623,15 @@ void afxCamera::cam_update_3pov(F32 dt, bool on_server)
MatrixF head_pitch_mtx(EulerF(head_pitch,0,0)); MatrixF head_pitch_mtx(EulerF(head_pitch,0,0));
xfm.mul(head_pitch_mtx); xfm.mul(head_pitch_mtx);
VectorF behind_vec(0, cam_offset.y, 0); VectorF behind_vec(0, mCam_offset.y, 0);
xfm.mulP(behind_vec, &goal_pos); xfm.mulP(behind_vec, &goal_pos);
goal_pos.z += cam_offset.z; goal_pos.z += mCam_offset.z;
} }
} }
// for non-player subjects, camera will follow, but pitch won't adjust. // for non-player subjects, camera will follow, but pitch won't adjust.
else else
{ {
xfm.mulP(cam_offset, &goal_pos); xfm.mulP(mCam_offset, &goal_pos);
} }
// avoid view occlusion // avoid view occlusion
@ -639,7 +639,7 @@ void afxCamera::cam_update_3pov(F32 dt, bool on_server)
{ {
// snap to final position if path to goal is blocked // snap to final position if path to goal is blocked
if (test_blocked_line(curr_pos, goal_pos)) if (test_blocked_line(curr_pos, goal_pos))
third_person_snap_c++; mThird_person_snap_c++;
} }
// place camera into its final position // place camera into its final position
@ -653,11 +653,11 @@ void afxCamera::cam_update_3pov(F32 dt, bool on_server)
F32 time_inc = 1.0f/speed_factor; F32 time_inc = 1.0f/speed_factor;
// snap to final position // snap to final position
if (on_server || (third_person_snap_c > 0 || dt > time_inc)) if (on_server || (mThird_person_snap_c > 0 || dt > time_inc))
{ {
snapToPosition(goal_pos); snapToPosition(goal_pos);
if (!on_server && third_person_snap_c > 0) if (!on_server && mThird_person_snap_c > 0)
third_person_snap_c--; mThird_person_snap_c--;
return; return;
} }
// interpolate to final position // interpolate to final position
@ -732,13 +732,13 @@ void afxCamera::onDeleteNotify(SimObject *obj)
if (obj == (SimObject*)mOrbitObject) if (obj == (SimObject*)mOrbitObject)
{ {
mOrbitObject = NULL; mOrbitObject = NULL;
if (mode == OrbitObjectMode) if (mMode == OrbitObjectMode)
mode = OrbitPointMode; mMode = OrbitPointMode;
} }
if (obj == cam_subject) if (obj == mCam_subject)
{ {
cam_subject = NULL; mCam_subject = NULL;
} }
} }
@ -748,12 +748,12 @@ void afxCamera::advanceTime(F32 dt)
if (gSFX3DWorld) if (gSFX3DWorld)
{ {
if (mode == ThirdPersonMode && cam_subject) if (mMode == ThirdPersonMode && mCam_subject)
{ {
if (gSFX3DWorld->getListener() != cam_subject) if (gSFX3DWorld->getListener() != mCam_subject)
gSFX3DWorld->setListener(cam_subject); gSFX3DWorld->setListener(mCam_subject);
} }
else if (mode == FlyMode) else if (mMode == FlyMode)
{ {
if (gSFX3DWorld->getListener() != this) if (gSFX3DWorld->getListener() != this)
gSFX3DWorld->setListener(this); gSFX3DWorld->setListener(this);
@ -772,15 +772,15 @@ void afxCamera::processTick(const Move* move)
if (move) if (move)
{ {
// UPDATE ORIENTATION // // UPDATE ORIENTATION //
delta.rotVec = mRot; mDelta.rotVec = mRot;
mObjToWorld.getColumn(3, &delta.posVec); mObjToWorld.getColumn(3, &mDelta.posVec);
mRot.x = mClampF(mRot.x + move->pitch, -MaxPitch, MaxPitch); mRot.x = mClampF(mRot.x + move->pitch, -MaxPitch, MaxPitch);
mRot.z += move->yaw; mRot.z += move->yaw;
// ORBIT MODE // // ORBIT MODE //
if (mode == OrbitObjectMode || mode == OrbitPointMode) if (mMode == OrbitObjectMode || mMode == OrbitPointMode)
{ {
if(mode == OrbitObjectMode && bool(mOrbitObject)) if(mMode == OrbitObjectMode && bool(mOrbitObject))
{ {
// If this is a shapebase, use its render eye transform // If this is a shapebase, use its render eye transform
// to avoid jittering. // to avoid jittering.
@ -823,10 +823,10 @@ void afxCamera::processTick(const Move* move)
// If on the client, calc delta for backstepping // If on the client, calc delta for backstepping
if (isClientObject()) if (isClientObject())
{ {
delta.pos = pos; mDelta.pos = pos;
delta.rot = mRot; mDelta.rot = mRot;
delta.posVec = delta.posVec - delta.pos; mDelta.posVec = mDelta.posVec - mDelta.pos;
delta.rotVec = delta.rotVec - delta.rot; mDelta.rotVec = mDelta.rotVec - mDelta.rot;
} }
else else
{ {
@ -847,14 +847,14 @@ void afxCamera::interpolateTick(F32 dt)
{ {
Parent::interpolateTick(dt); Parent::interpolateTick(dt);
if (mode == ThirdPersonMode) if (mMode == ThirdPersonMode)
return; return;
Point3F rot = delta.rot + delta.rotVec * dt; Point3F rot = mDelta.rot + mDelta.rotVec * dt;
if(mode == OrbitObjectMode || mode == OrbitPointMode) if(mMode == OrbitObjectMode || mMode == OrbitPointMode)
{ {
if(mode == OrbitObjectMode && bool(mOrbitObject)) if(mMode == OrbitObjectMode && bool(mOrbitObject))
{ {
// If this is a shapebase, use its render eye transform // If this is a shapebase, use its render eye transform
// to avoid jittering. // to avoid jittering.
@ -880,7 +880,7 @@ void afxCamera::interpolateTick(F32 dt)
{ {
// NOTE - posVec is 0,0,0 unless cam is control-object and process tick is // NOTE - posVec is 0,0,0 unless cam is control-object and process tick is
// updating the delta // updating the delta
Point3F pos = delta.pos + delta.posVec * dt; Point3F pos = mDelta.pos + mDelta.posVec * dt;
set_cam_pos(pos,rot); set_cam_pos(pos,rot);
} }
} }
@ -896,19 +896,19 @@ void afxCamera::writePacketData(GameConnection *connection, BitStream *bstream)
bstream->write(mRot.x); // SND X ROT bstream->write(mRot.x); // SND X ROT
bstream->write(mRot.z); // SND Z ROT bstream->write(mRot.z); // SND Z ROT
if (bstream->writeFlag(cam_dirty)) if (bstream->writeFlag(mCam_dirty))
{ {
mathWrite(*bstream, cam_offset); // SND CAM_OFFSET mathWrite(*bstream, mCam_offset); // SND CAM_OFFSET
mathWrite(*bstream, coi_offset); // SND COI_OFFSET mathWrite(*bstream, mCoi_offset); // SND COI_OFFSET
bstream->write(cam_distance); bstream->write(mCam_distance);
bstream->write(cam_angle); bstream->write(mCam_angle);
cam_dirty = false; mCam_dirty = false;
} }
U32 writeMode = mode; U32 writeMode = mMode;
Point3F writePos = mPosition; Point3F writePos = mPosition;
S32 gIndex = -1; S32 gIndex = -1;
if (mode == OrbitObjectMode) if (mMode == OrbitObjectMode)
{ {
gIndex = bool(mOrbitObject) ? connection->getGhostIndex(mOrbitObject): -1; gIndex = bool(mOrbitObject) ? connection->getGhostIndex(mOrbitObject): -1;
if(gIndex == -1) if(gIndex == -1)
@ -921,9 +921,9 @@ void afxCamera::writePacketData(GameConnection *connection, BitStream *bstream)
bstream->writeRangedU32(writeMode, CameraFirstMode, CameraLastMode); // SND MODE bstream->writeRangedU32(writeMode, CameraFirstMode, CameraLastMode); // SND MODE
if (writeMode == ThirdPersonMode) if (writeMode == ThirdPersonMode)
{ {
bstream->write(third_person_snap_s > 0); // SND SNAP bstream->write(mThird_person_snap_s > 0); // SND SNAP
if (third_person_snap_s > 0) if (mThird_person_snap_s > 0)
third_person_snap_s--; mThird_person_snap_s--;
} }
if (writeMode == OrbitObjectMode || writeMode == OrbitPointMode) if (writeMode == OrbitObjectMode || writeMode == OrbitPointMode)
@ -956,34 +956,34 @@ void afxCamera::readPacketData(GameConnection *connection, BitStream *bstream)
Point3F new_cam_offset, new_coi_offset; Point3F new_cam_offset, new_coi_offset;
mathRead(*bstream, &new_cam_offset); // RCV CAM_OFFSET mathRead(*bstream, &new_cam_offset); // RCV CAM_OFFSET
mathRead(*bstream, &new_coi_offset); // RCV COI_OFFSET mathRead(*bstream, &new_coi_offset); // RCV COI_OFFSET
bstream->read(&cam_distance); bstream->read(&mCam_distance);
bstream->read(&cam_angle); bstream->read(&mCam_angle);
setThirdPersonOffset(new_cam_offset, new_coi_offset); setThirdPersonOffset(new_cam_offset, new_coi_offset);
} }
GameBase* obj = 0; GameBase* obj = 0;
mode = bstream->readRangedU32(CameraFirstMode, // RCV MODE mMode = bstream->readRangedU32(CameraFirstMode, // RCV MODE
CameraLastMode); CameraLastMode);
if (mode == ThirdPersonMode) if (mMode == ThirdPersonMode)
{ {
bool snap; bstream->read(&snap); bool snap; bstream->read(&snap);
if (snap) if (snap)
third_person_snap_c++; mThird_person_snap_c++;
} }
mObservingClientObject = false; mObservingClientObject = false;
if (mode == OrbitObjectMode || mode == OrbitPointMode) { if (mMode == OrbitObjectMode || mMode == OrbitPointMode) {
bstream->read(&mMinOrbitDist); bstream->read(&mMinOrbitDist);
bstream->read(&mMaxOrbitDist); bstream->read(&mMaxOrbitDist);
bstream->read(&mCurOrbitDist); bstream->read(&mCurOrbitDist);
if(mode == OrbitObjectMode) if(mMode == OrbitObjectMode)
{ {
mObservingClientObject = bstream->readFlag(); mObservingClientObject = bstream->readFlag();
S32 gIndex = bstream->readInt(NetConnection::GhostIdBitSize); S32 gIndex = bstream->readInt(NetConnection::GhostIdBitSize);
obj = static_cast<GameBase*>(connection->resolveGhost(gIndex)); obj = static_cast<GameBase*>(connection->resolveGhost(gIndex));
} }
if (mode == OrbitPointMode) if (mMode == OrbitPointMode)
bstream->readCompressedPoint(&mPosition); bstream->readCompressedPoint(&mPosition);
} }
if (obj != (GameBase*)mOrbitObject) { if (obj != (GameBase*)mOrbitObject) {
@ -998,14 +998,14 @@ void afxCamera::readPacketData(GameConnection *connection, BitStream *bstream)
} }
} }
if (mode == ThirdPersonMode) if (mMode == ThirdPersonMode)
return; return;
set_cam_pos(pos,rot); set_cam_pos(pos,rot);
delta.pos = pos; mDelta.pos = pos;
delta.rot = rot; mDelta.rot = rot;
delta.rotVec.set(0,0,0); mDelta.rotVec.set(0,0,0);
delta.posVec.set(0,0,0); mDelta.posVec.set(0,0,0);
} }
U32 afxCamera::packUpdate(NetConnection* conn, U32 mask, BitStream *bstream) U32 afxCamera::packUpdate(NetConnection* conn, U32 mask, BitStream *bstream)
@ -1029,10 +1029,10 @@ U32 afxCamera::packUpdate(NetConnection* conn, U32 mask, BitStream *bstream)
if (bstream->writeFlag(mask & SubjectMask)) if (bstream->writeFlag(mask & SubjectMask))
{ {
S32 ghost_id = (cam_subject) ? conn->getGhostIndex(cam_subject) : -1; S32 ghost_id = (mCam_subject) ? conn->getGhostIndex(mCam_subject) : -1;
if (bstream->writeFlag(ghost_id != -1)) if (bstream->writeFlag(ghost_id != -1))
bstream->writeRangedU32(U32(ghost_id), 0, NetConnection::MaxGhostCount); bstream->writeRangedU32(U32(ghost_id), 0, NetConnection::MaxGhostCount);
else if (cam_subject) else if (mCam_subject)
retMask |= SubjectMask; retMask |= SubjectMask;
} }
@ -1057,9 +1057,9 @@ void afxCamera::unpackUpdate(NetConnection *conn, BitStream *bstream)
set_cam_pos(pos,rot); set_cam_pos(pos,rot);
// New delta for client side interpolation // New delta for client side interpolation
delta.pos = pos; mDelta.pos = pos;
delta.rot = rot; mDelta.rot = rot;
delta.posVec = delta.rotVec = VectorF(0,0,0); mDelta.posVec = mDelta.rotVec = VectorF(0,0,0);
} }
if (bstream->readFlag()) if (bstream->readFlag())
@ -1067,18 +1067,18 @@ void afxCamera::unpackUpdate(NetConnection *conn, BitStream *bstream)
if (bstream->readFlag()) if (bstream->readFlag())
{ {
S32 ghost_id = bstream->readRangedU32(0, NetConnection::MaxGhostCount); S32 ghost_id = bstream->readRangedU32(0, NetConnection::MaxGhostCount);
cam_subject = dynamic_cast<GameBase*>(conn->resolveGhost(ghost_id)); mCam_subject = dynamic_cast<GameBase*>(conn->resolveGhost(ghost_id));
} }
else else
cam_subject = NULL; mCam_subject = NULL;
} }
} }
// Override to ensure both are kept in scope // Override to ensure both are kept in scope
void afxCamera::onCameraScopeQuery(NetConnection* conn, CameraScopeQuery* query) void afxCamera::onCameraScopeQuery(NetConnection* conn, CameraScopeQuery* query)
{ {
if (cam_subject) if (mCam_subject)
conn->objectInScope(cam_subject); conn->objectInScope(mCam_subject);
Parent::onCameraScopeQuery(conn, query); Parent::onCameraScopeQuery(conn, query);
} }
@ -1156,7 +1156,7 @@ void afxCamera::setCameraFov(F32 fov)
F32 afxCamera::getDamageFlash() const F32 afxCamera::getDamageFlash() const
{ {
if (mode == OrbitObjectMode && isServerObject() && bool(mOrbitObject)) if (mMode == OrbitObjectMode && isServerObject() && bool(mOrbitObject))
{ {
const GameBase *castObj = mOrbitObject; const GameBase *castObj = mOrbitObject;
const ShapeBase* psb = dynamic_cast<const ShapeBase*>(castObj); const ShapeBase* psb = dynamic_cast<const ShapeBase*>(castObj);
@ -1169,7 +1169,7 @@ F32 afxCamera::getDamageFlash() const
F32 afxCamera::getWhiteOut() const F32 afxCamera::getWhiteOut() const
{ {
if (mode == OrbitObjectMode && isServerObject() && bool(mOrbitObject)) if (mMode == OrbitObjectMode && isServerObject() && bool(mOrbitObject))
{ {
const GameBase *castObj = mOrbitObject; const GameBase *castObj = mOrbitObject;
const ShapeBase* psb = dynamic_cast<const ShapeBase*>(castObj); const ShapeBase* psb = dynamic_cast<const ShapeBase*>(castObj);

30
Engine/source/afx/afxCamera.h
View file

@ -88,9 +88,9 @@ class afxCamera: public ShapeBase
}; };
private: private:
int mode; int mMode;
Point3F mRot; Point3F mRot;
StateDelta delta; StateDelta mDelta;
SimObjectPtr<GameBase> mOrbitObject; SimObjectPtr<GameBase> mOrbitObject;
F32 mMinOrbitDist; F32 mMinOrbitDist;
@ -99,17 +99,17 @@ private:
Point3F mPosition; Point3F mPosition;
bool mObservingClientObject; bool mObservingClientObject;
SceneObject* cam_subject; SceneObject* mCam_subject;
Point3F cam_offset; Point3F mCam_offset;
Point3F coi_offset; Point3F mCoi_offset;
F32 cam_distance; F32 mCam_distance;
F32 cam_angle; F32 mCam_angle;
bool cam_dirty; bool mCam_dirty;
bool flymode_saved; bool mFlymode_saved;
Point3F flymode_saved_pos; Point3F mFlymode_saved_pos;
S8 third_person_snap_c; S8 mThird_person_snap_c;
S8 third_person_snap_s; S8 mThird_person_snap_s;
void set_cam_pos(const Point3F& pos, const Point3F& viewRot); void set_cam_pos(const Point3F& pos, const Point3F& viewRot);
void cam_update(F32 dt, bool on_server); void cam_update(F32 dt, bool on_server);
@ -130,8 +130,8 @@ public:
void setCameraSubject(SceneObject* subject); void setCameraSubject(SceneObject* subject);
void setThirdPersonOffset(const Point3F& offset); void setThirdPersonOffset(const Point3F& offset);
void setThirdPersonOffset(const Point3F& offset, const Point3F& coi_offset); void setThirdPersonOffset(const Point3F& offset, const Point3F& coi_offset);
const Point3F& getThirdPersonOffset() const { return cam_offset; } const Point3F& getThirdPersonOffset() const { return mCam_offset; }
const Point3F& getThirdPersonCOIOffset() const { return coi_offset; } const Point3F& getThirdPersonCOIOffset() const { return mCoi_offset; }
void setThirdPersonDistance(F32 distance); void setThirdPersonDistance(F32 distance);
F32 getThirdPersonDistance(); F32 getThirdPersonDistance();
void setThirdPersonAngle(F32 angle); void setThirdPersonAngle(F32 angle);
@ -147,7 +147,7 @@ public:
DECLARE_CATEGORY("AFX"); DECLARE_CATEGORY("AFX");
private: // 3POV SECTION private: // 3POV SECTION
U32 blockers_mask_3pov; U32 mBlockers_mask_3pov;
void cam_update_3pov(F32 dt, bool on_server); void cam_update_3pov(F32 dt, bool on_server);
bool avoid_blocked_view(const Point3F& start, const Point3F& end, Point3F& newpos); bool avoid_blocked_view(const Point3F& start, const Point3F& end, Point3F& newpos);