mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-02-13 19:53:48 +00:00
Other renames to ensure linux case-sensitivity compliance and casing format consistency.
This commit is contained in:
Areloch
parent
93e767f0c5
commit
f5e86a83b5
33 changed files with 0 additions and 0 deletions
483
Engine/source/T3D/components/camera/cameraComponent.cpp
Normal file
483
Engine/source/T3D/components/camera/cameraComponent.cpp
Normal file
|
|
@ -0,0 +1,483 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (c) 2012 GarageGames, LLC
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to
|
||||
// deal in the Software without restriction, including without limitation the
|
||||
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
// sell copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||||
// IN THE SOFTWARE.
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "T3D/components/camera/cameracomponent.h"
|
||||
#include "T3D/components/camera/cameraComponent_ScriptBinding.h"
|
||||
#include "platform/platform.h"
|
||||
#include "console/consoleTypes.h"
|
||||
#include "core/util/safeDelete.h"
|
||||
#include "core/resourceManager.h"
|
||||
#include "core/stream/fileStream.h"
|
||||
#include "console/consoleTypes.h"
|
||||
#include "console/consoleObject.h"
|
||||
#include "ts/tsShapeInstance.h"
|
||||
#include "core/stream/bitStream.h"
|
||||
#include "gfx/gfxTransformSaver.h"
|
||||
#include "console/engineAPI.h"
|
||||
#include "lighting/lightQuery.h"
|
||||
#include "T3D/gameBase/gameConnection.h"
|
||||
#include "T3D/gameFunctions.h"
|
||||
#include "math/mathUtils.h"
|
||||
#include "T3D/components/render/renderComponentInterface.h"
|
||||
|
||||
IMPLEMENT_CALLBACK( CameraComponent, validateCameraFov, F32, (F32 fov), (fov),
|
||||
"@brief Called on the server when the client has requested a FOV change.\n\n"
|
||||
|
||||
"When the client requests that its field of view should be changed (because "
|
||||
"they want to use a sniper scope, for example) this new FOV needs to be validated "
|
||||
"by the server. This method is called if it exists (it is optional) to validate "
|
||||
"the requested FOV, and modify it if necessary. This could be as simple as checking "
|
||||
"that the FOV falls within a correct range, to making sure that the FOV matches the "
|
||||
"capabilities of the current weapon.\n\n"
|
||||
|
||||
"Following this method, ShapeBase ensures that the given FOV still falls within "
|
||||
"the datablock's mCameraMinFov and mCameraMaxFov. If that is good enough for your "
|
||||
"purposes, then you do not need to define the validateCameraFov() callback for "
|
||||
"your ShapeBase.\n\n"
|
||||
|
||||
"@param fov The FOV that has been requested by the client.\n"
|
||||
"@return The FOV as validated by the server.\n\n"
|
||||
|
||||
"@see ShapeBaseData\n\n");
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// Constructor/Destructor
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
CameraComponent::CameraComponent() : Component()
|
||||
{
|
||||
mClientScreen = Point2F(1, 1);
|
||||
|
||||
mCameraFov = mCameraDefaultFov = 80;
|
||||
mCameraMinFov = 5;
|
||||
mCameraMaxFov = 175;
|
||||
|
||||
mTargetNodeIdx = -1;
|
||||
|
||||
mPosOffset = Point3F(0, 0, 0);
|
||||
mRotOffset = EulerF(0, 0, 0);
|
||||
|
||||
mTargetNode = "";
|
||||
|
||||
mUseParentTransform = true;
|
||||
|
||||
mFriendlyName = "Camera(Component)";
|
||||
}
|
||||
|
||||
CameraComponent::~CameraComponent()
|
||||
{
|
||||
for(S32 i = 0;i < mFields.size();++i)
|
||||
{
|
||||
ComponentField &field = mFields[i];
|
||||
SAFE_DELETE_ARRAY(field.mFieldDescription);
|
||||
}
|
||||
|
||||
SAFE_DELETE_ARRAY(mDescription);
|
||||
}
|
||||
|
||||
IMPLEMENT_CO_NETOBJECT_V1(CameraComponent);
|
||||
|
||||
bool CameraComponent::onAdd()
|
||||
{
|
||||
if(! Parent::onAdd())
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CameraComponent::onRemove()
|
||||
{
|
||||
Parent::onRemove();
|
||||
}
|
||||
|
||||
void CameraComponent::initPersistFields()
|
||||
{
|
||||
Parent::initPersistFields();
|
||||
|
||||
addProtectedField("FOV", TypeF32, Offset(mCameraFov, CameraComponent), &_setCameraFov, defaultProtectedGetFn, "");
|
||||
|
||||
addField("MinFOV", TypeF32, Offset(mCameraMinFov, CameraComponent), "");
|
||||
|
||||
addField("MaxFOV", TypeF32, Offset(mCameraMaxFov, CameraComponent), "");
|
||||
|
||||
addField("ScreenAspect", TypePoint2I, Offset(mClientScreen, CameraComponent), "");
|
||||
|
||||
addProtectedField("targetNode", TypeString, Offset(mTargetNode, CameraComponent), &_setNode, defaultProtectedGetFn, "");
|
||||
|
||||
addProtectedField("positionOffset", TypePoint3F, Offset(mPosOffset, CameraComponent), &_setPosOffset, defaultProtectedGetFn, "");
|
||||
|
||||
addProtectedField("rotationOffset", TypeRotationF, Offset(mRotOffset, CameraComponent), &_setRotOffset, defaultProtectedGetFn, "");
|
||||
|
||||
addField("useParentTransform", TypeBool, Offset(mUseParentTransform, CameraComponent), "");
|
||||
}
|
||||
|
||||
bool CameraComponent::_setNode(void *object, const char *index, const char *data)
|
||||
{
|
||||
CameraComponent *mcc = static_cast<CameraComponent*>(object);
|
||||
|
||||
mcc->mTargetNode = StringTable->insert(data);
|
||||
mcc->setMaskBits(OffsetMask);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CameraComponent::_setPosOffset(void *object, const char *index, const char *data)
|
||||
{
|
||||
CameraComponent *mcc = static_cast<CameraComponent*>(object);
|
||||
|
||||
if (mcc)
|
||||
{
|
||||
Point3F pos;
|
||||
Con::setData(TypePoint3F, &pos, 0, 1, &data);
|
||||
|
||||
mcc->mPosOffset = pos;
|
||||
mcc->setMaskBits(OffsetMask);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CameraComponent::_setRotOffset(void *object, const char *index, const char *data)
|
||||
{
|
||||
CameraComponent *mcc = static_cast<CameraComponent*>(object);
|
||||
|
||||
if (mcc)
|
||||
{
|
||||
RotationF rot;
|
||||
Con::setData(TypeRotationF, &rot, 0, 1, &data);
|
||||
|
||||
mcc->mRotOffset = rot;
|
||||
mcc->setMaskBits(OffsetMask);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CameraComponent::isValidCameraFov(F32 fov)
|
||||
{
|
||||
return((fov >= mCameraMinFov) && (fov <= mCameraMaxFov));
|
||||
}
|
||||
|
||||
bool CameraComponent::_setCameraFov(void *object, const char *index, const char *data)
|
||||
{
|
||||
CameraComponent *cCI = static_cast<CameraComponent*>(object);
|
||||
cCI->setCameraFov(dAtof(data));
|
||||
return true;
|
||||
}
|
||||
|
||||
void CameraComponent::setCameraFov(F32 fov)
|
||||
{
|
||||
mCameraFov = mClampF(fov, mCameraMinFov, mCameraMaxFov);
|
||||
|
||||
if (isClientObject())
|
||||
GameSetCameraTargetFov(mCameraFov);
|
||||
|
||||
if (isServerObject())
|
||||
setMaskBits(FOVMask);
|
||||
}
|
||||
|
||||
void CameraComponent::onCameraScopeQuery(NetConnection *cr, CameraScopeQuery * query)
|
||||
{
|
||||
// update the camera query
|
||||
query->camera = this;
|
||||
|
||||
if(GameConnection * con = dynamic_cast<GameConnection*>(cr))
|
||||
{
|
||||
// get the fov from the connection (in deg)
|
||||
F32 fov;
|
||||
if (con->getControlCameraFov(&fov))
|
||||
{
|
||||
query->fov = mDegToRad(fov/2);
|
||||
query->sinFov = mSin(query->fov);
|
||||
query->cosFov = mCos(query->fov);
|
||||
}
|
||||
else
|
||||
{
|
||||
query->fov = mDegToRad(mCameraFov/2);
|
||||
query->sinFov = mSin(query->fov);
|
||||
query->cosFov = mCos(query->fov);
|
||||
}
|
||||
}
|
||||
|
||||
// use eye rather than camera transform (good enough and faster)
|
||||
MatrixF camTransform = mOwner->getTransform();
|
||||
camTransform.getColumn(3, &query->pos);
|
||||
camTransform.getColumn(1, &query->orientation);
|
||||
|
||||
// Get the visible distance.
|
||||
if (mOwner->getSceneManager() != NULL)
|
||||
query->visibleDistance = mOwner->getSceneManager()->getVisibleDistance();
|
||||
}
|
||||
|
||||
bool CameraComponent::getCameraTransform(F32* pos,MatrixF* mat)
|
||||
{
|
||||
// Returns camera to world space transform
|
||||
// Handles first person / third person camera position
|
||||
bool isServer = isServerObject();
|
||||
|
||||
if (mTargetNodeIdx == -1)
|
||||
{
|
||||
if (mUseParentTransform)
|
||||
{
|
||||
MatrixF rMat = mOwner->getRenderTransform();
|
||||
|
||||
rMat.mul(mRotOffset.asMatrixF());
|
||||
|
||||
mat->set(rMat.toEuler(), rMat.getPosition() + mPosOffset);
|
||||
}
|
||||
else
|
||||
{
|
||||
mat->set(mRotOffset.asEulerF(), mPosOffset);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
RenderComponentInterface *renderInterface = mOwner->getComponent<RenderComponentInterface>();
|
||||
|
||||
if (!renderInterface)
|
||||
return false;
|
||||
|
||||
if (mUseParentTransform)
|
||||
{
|
||||
MatrixF rMat = mOwner->getRenderTransform();
|
||||
|
||||
Point3F position = rMat.getPosition();
|
||||
|
||||
RotationF rot = mRotOffset;
|
||||
|
||||
if (mTargetNodeIdx != -1)
|
||||
{
|
||||
Point3F nodPos;
|
||||
MatrixF nodeTrans = renderInterface->getNodeTransform(mTargetNodeIdx);
|
||||
nodeTrans.getColumn(3, &nodPos);
|
||||
|
||||
// Scale the camera position before applying the transform
|
||||
const Point3F& scale = mOwner->getScale();
|
||||
nodPos.convolve(scale);
|
||||
|
||||
mOwner->getRenderTransform().mulP(nodPos, &position);
|
||||
|
||||
nodeTrans.mul(rMat);
|
||||
|
||||
rot = nodeTrans;
|
||||
}
|
||||
|
||||
position += mPosOffset;
|
||||
|
||||
MatrixF rotMat = rot.asMatrixF();
|
||||
|
||||
MatrixF rotOffsetMat = mRotOffset.asMatrixF();
|
||||
|
||||
rotMat.mul(rotOffsetMat);
|
||||
|
||||
rot = RotationF(rotMat);
|
||||
|
||||
mat->set(rot.asEulerF(), position);
|
||||
}
|
||||
else
|
||||
{
|
||||
MatrixF rMat = mOwner->getRenderTransform();
|
||||
|
||||
Point3F position = rMat.getPosition();
|
||||
|
||||
RotationF rot = mRotOffset;
|
||||
|
||||
if (mTargetNodeIdx != -1)
|
||||
{
|
||||
Point3F nodPos;
|
||||
MatrixF nodeTrans = renderInterface->getNodeTransform(mTargetNodeIdx);
|
||||
nodeTrans.getColumn(3, &nodPos);
|
||||
|
||||
// Scale the camera position before applying the transform
|
||||
const Point3F& scale = mOwner->getScale();
|
||||
nodPos.convolve(scale);
|
||||
|
||||
position = nodPos;
|
||||
}
|
||||
|
||||
position += mPosOffset;
|
||||
|
||||
mat->set(rot.asEulerF(), position);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
void CameraComponent::getCameraParameters(F32 *min, F32* max, Point3F* off, MatrixF* rot)
|
||||
{
|
||||
*min = 0.2f;
|
||||
*max = 0.f;
|
||||
off->set(0, 0, 0);
|
||||
rot->identity();
|
||||
}
|
||||
|
||||
U32 CameraComponent::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
|
||||
{
|
||||
U32 retmask = Parent::packUpdate(con, mask, stream);
|
||||
|
||||
if (stream->writeFlag(mask & FOVMask))
|
||||
{
|
||||
stream->write(mCameraFov);
|
||||
}
|
||||
|
||||
if (stream->writeFlag(mask & OffsetMask))
|
||||
{
|
||||
RenderComponentInterface* renderInterface = getOwner()->getComponent<RenderComponentInterface>();
|
||||
|
||||
if (renderInterface && renderInterface->getShape())
|
||||
{
|
||||
S32 nodeIndex = renderInterface->getShape()->findNode(mTargetNode);
|
||||
|
||||
mTargetNodeIdx = nodeIndex;
|
||||
}
|
||||
|
||||
stream->writeInt(mTargetNodeIdx, 32);
|
||||
//send offsets here
|
||||
|
||||
stream->writeCompressedPoint(mPosOffset);
|
||||
stream->writeCompressedPoint(mRotOffset.asEulerF());
|
||||
|
||||
stream->writeFlag(mUseParentTransform);
|
||||
}
|
||||
|
||||
return retmask;
|
||||
}
|
||||
|
||||
void CameraComponent::unpackUpdate(NetConnection *con, BitStream *stream)
|
||||
{
|
||||
Parent::unpackUpdate(con, stream);
|
||||
|
||||
if (stream->readFlag())
|
||||
{
|
||||
F32 fov;
|
||||
stream->read(&fov);
|
||||
setCameraFov(fov);
|
||||
}
|
||||
|
||||
if(stream->readFlag())
|
||||
{
|
||||
mTargetNodeIdx = stream->readInt(32);
|
||||
|
||||
stream->readCompressedPoint(&mPosOffset);
|
||||
|
||||
EulerF rot;
|
||||
stream->readCompressedPoint(&rot);
|
||||
|
||||
mRotOffset = RotationF(rot);
|
||||
|
||||
mUseParentTransform = stream->readFlag();
|
||||
}
|
||||
}
|
||||
|
||||
void CameraComponent::setForwardVector(VectorF newForward, VectorF upVector)
|
||||
{
|
||||
MatrixF mat;
|
||||
F32 pos = 0;
|
||||
getCameraTransform(&pos, &mat);
|
||||
|
||||
mPosOffset = mat.getPosition();
|
||||
|
||||
VectorF up(0.0f, 0.0f, 1.0f);
|
||||
VectorF axisX;
|
||||
VectorF axisY = newForward;
|
||||
VectorF axisZ;
|
||||
|
||||
if (upVector != VectorF::Zero)
|
||||
up = upVector;
|
||||
|
||||
// Validate and normalize input:
|
||||
F32 lenSq;
|
||||
lenSq = axisY.lenSquared();
|
||||
if (lenSq < 0.000001f)
|
||||
{
|
||||
axisY.set(0.0f, 1.0f, 0.0f);
|
||||
Con::errorf("Entity::setForwardVector() - degenerate forward vector");
|
||||
}
|
||||
else
|
||||
{
|
||||
axisY /= mSqrt(lenSq);
|
||||
}
|
||||
|
||||
lenSq = up.lenSquared();
|
||||
if (lenSq < 0.000001f)
|
||||
{
|
||||
up.set(0.0f, 0.0f, 1.0f);
|
||||
Con::errorf("SceneObject::setForwardVector() - degenerate up vector - too small");
|
||||
}
|
||||
else
|
||||
{
|
||||
up /= mSqrt(lenSq);
|
||||
}
|
||||
|
||||
if (fabsf(mDot(up, axisY)) > 0.9999f)
|
||||
{
|
||||
Con::errorf("SceneObject::setForwardVector() - degenerate up vector - same as forward");
|
||||
// i haven't really tested this, but i think it generates something which should be not parallel to the previous vector:
|
||||
F32 tmp = up.x;
|
||||
up.x = -up.y;
|
||||
up.y = up.z;
|
||||
up.z = tmp;
|
||||
}
|
||||
|
||||
// construct the remaining axes:
|
||||
mCross(axisY, up, &axisX);
|
||||
mCross(axisX, axisY, &axisZ);
|
||||
|
||||
mat.setColumn(0, axisX);
|
||||
mat.setColumn(1, axisY);
|
||||
mat.setColumn(2, axisZ);
|
||||
|
||||
mRotOffset = RotationF(mat.toEuler());
|
||||
mRotOffset.y = 0;
|
||||
|
||||
setMaskBits(OffsetMask);
|
||||
}
|
||||
|
||||
void CameraComponent::setPosition(Point3F newPos)
|
||||
{
|
||||
mPosOffset = newPos;
|
||||
setMaskBits(OffsetMask);
|
||||
}
|
||||
|
||||
void CameraComponent::setRotation(RotationF newRot)
|
||||
{
|
||||
mRotOffset = newRot;
|
||||
setMaskBits(OffsetMask);
|
||||
}
|
||||
|
||||
Frustum CameraComponent::getFrustum()
|
||||
{
|
||||
Frustum visFrustum;
|
||||
F32 left, right, top, bottom;
|
||||
F32 aspectRatio = mClientScreen.x / mClientScreen.y;
|
||||
|
||||
visFrustum.set(false, mDegToRad(mCameraFov), aspectRatio, 0.1f, 1000, mOwner->getTransform());
|
||||
|
||||
return visFrustum;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue