//----------------------------------------------------------------------------- // Torque Game Engine // Copyright (C) GarageGames.com, Inc. // @author Stefan "Beffy" Moises // this is a modified version of PathCamera that allows to move shapes along paths //----------------------------------------------------------------------------- #include "platform/platform.h" #include "math/mMath.h" #include "math/mathIO.h" #include "console/simBase.h" #include "console/console.h" #include "console/consoleTypes.h" #include "core/stream/bitStream.h" #include "core/dnet.h" #include "scene/pathManager.h" #include "T3D/gameFunctions.h" #include "T3D/gameBase/gameConnection.h" #include "gui/worldEditor/editor.h" #include "console/engineAPI.h" #include "math/mTransform.h" #include "T3D/pathShape.h" //---------------------------------------------------------------------------- IMPLEMENT_CO_DATABLOCK_V1(PathShapeData); void PathShapeData::consoleInit() { } bool PathShapeData::preload(bool server, String &errorStr) { if(!Parent::preload(server, errorStr)) return false; return true; } void PathShapeData::initPersistFields() { docsURL; Parent::initPersistFields(); } void PathShapeData::packData(BitStream* stream) { Parent::packData(stream); } void PathShapeData::unpackData(BitStream* stream) { Parent::unpackData(stream); } //---------------------------------------------------------------------------- IMPLEMENT_CO_NETOBJECT_V1(PathShape); PathShape::PathShape() { mNetFlags.set(Ghostable|ScopeAlways); mTypeMask |= PathShapeObjectType | StaticShapeObjectType; delta.time = 0; delta.timeVec = 0; mDataBlock = NULL; mState = Forward; mNodeBase = 0; mNodeCount = 0; mPosition = 0; mTarget = 0; mTargetSet = false; MatrixF mat = MatrixF::Identity; mLastXform = MatrixF::Identity; Parent::setTransform(mat); for (U32 i = 0; i < 4; i++) { mControl[i] = StringTable->insert(""); } } PathShape::~PathShape() { } //---------------------------------------------------------------------------- bool PathShape::onAdd() { if(!Parent::onAdd() && !mDataBlock) return false; mTypeMask |= PathShapeObjectType | StaticShapeObjectType; // Initialize from the current transform. if (!mNodeCount) { QuatF rot(getTransform()); Point3F pos = getPosition(); mSpline.removeAll(); mSpline.push_back(new CameraSpline::Knot(pos,rot,1, CameraSpline::Knot::NORMAL, CameraSpline::Knot::SPLINE)); mNodeCount = 1; } if (isServerObject()) scriptOnAdd(); return true; } void PathShape::onRemove() { scriptOnRemove(); removeFromScene(); unmount(); Parent::onRemove(); if (isGhost()) for (S32 i = 0; i < MaxSoundThreads; i++) stopAudio(i); } bool PathShape::onNewDataBlock(GameBaseData* dptr, bool reload) { mDataBlock = dynamic_cast(dptr); if (!mDataBlock || !Parent::onNewDataBlock(dptr, reload)) return false; scriptOnNewDataBlock(); return true; } PathShapeData::PathShapeData() { } //---------------------------------------------------------------------------- void PathShape::initPersistFields() { docsURL; addField( "Path", TYPEID< SimObjectRef >(), Offset( mSimPath, PathShape ), "@brief Name of a Path to follow." ); addField("Controler", TypeString, Offset(mControl, PathShape), 4, "controlers"); Parent::initPersistFields(); } void PathShape::consoleInit() { } //---------------------------------------------------------------------------- void PathShape::processTick(const Move* move) { // client and server Parent::processTick(move); // Move to new time advancePosition(TickMs); MatrixF mat; interpolateMat(mPosition,&mat); Parent::setTransform(mat); updateContainer(); } void PathShape::interpolateTick(F32 dt) { Parent::interpolateTick(dt); MatrixF mat; interpolateMat(delta.time + (delta.timeVec * dt),&mat); Parent::setRenderTransform(mat); } void PathShape::interpolateMat(F32 pos,MatrixF* mat) { CameraSpline::Knot knot; mSpline.value(pos - mNodeBase,&knot); knot.mRotation.setMatrix(mat); mat->setPosition(knot.mPosition); } void PathShape::advancePosition(S32 ms) { delta.timeVec = mPosition; // Advance according to current speed if (mState == Forward) { mPosition = mSpline.advanceTime(mPosition - mNodeBase,ms); if (mPosition > F32(mNodeCount - 1)) mPosition = F32(mNodeCount - 1); mPosition += (F32)mNodeBase; if (mTargetSet && mPosition >= mTarget) { mTargetSet = false; mPosition = mTarget; mState = Stop; } } else if (mState == Backward) { mPosition = mSpline.advanceTime(mPosition - mNodeBase,-ms); if (mPosition < 0) mPosition = 0; mPosition += mNodeBase; if (mTargetSet && mPosition <= mTarget) { mTargetSet = false; mPosition = mTarget; mState = Stop; } } // Script callbacks if (int(mPosition) != int(delta.timeVec)) onNode(int(mPosition)); // Set frame interpolation delta.time = mPosition; delta.timeVec -= mPosition; } //---------------------------------------------------------------------------- void PathShape::setPosition(F32 pos) { mPosition = mClampF(pos,mNodeBase,mNodeBase + mNodeCount - 1); MatrixF mat; interpolateMat(mPosition,&mat); Parent::setTransform(mat); setMaskBits(PositionMask); } void PathShape::setTarget(F32 pos) { mTarget = pos; mTargetSet = true; if (mTarget > mPosition) mState = Forward; else if (mTarget < mPosition) mState = Backward; else { mTargetSet = false; mState = Stop; } setMaskBits(TargetMask | StateMask); } void PathShape::setState(State s) { mState = s; setMaskBits(StateMask); } S32 PathShape::getState() { return mState; } //----------------------------------------------------------------------------- void PathShape::reset(F32 speed) { CameraSpline::Knot *knot = new CameraSpline::Knot; mSpline.value(mPosition - mNodeBase,knot); if (speed) knot->mSpeed = speed; mSpline.removeAll(); mSpline.push_back(knot); mNodeBase = 0; mNodeCount = 1; mPosition = 0; mTargetSet = false; mState = Forward; setMaskBits(StateMask | PositionMask | WindowMask | TargetMask); } void PathShape::pushBack(CameraSpline::Knot *knot) { // Make room at the end if (mNodeCount == NodeWindow) { delete mSpline.remove(mSpline.getKnot(0)); mNodeBase++; } else mNodeCount++; // Fill in the new node mSpline.push_back(knot); setMaskBits(WindowMask); // Make sure the position doesn't fall off if (mPosition < mNodeBase) { mPosition = mNodeBase; setMaskBits(PositionMask); } } void PathShape::pushFront(CameraSpline::Knot *knot) { // Make room at the front if (mNodeCount == NodeWindow) delete mSpline.remove(mSpline.getKnot(mNodeCount)); else mNodeCount++; mNodeBase--; // Fill in the new node mSpline.push_front(knot); setMaskBits(WindowMask); // Make sure the position doesn't fall off if (mPosition > mNodeBase + (NodeWindow - 1)) { mPosition = mNodeBase + (NodeWindow - 1); setMaskBits(PositionMask); } } void PathShape::popFront() { if (mNodeCount < 2) return; // Remove the first node. Node base and position are unaffected. mNodeCount--; delete mSpline.remove(mSpline.getKnot(0)); } //---------------------------------------------------------------------------- void PathShape::onNode(S32 node) { if (!isGhost()) { Con::executef(mDataBlock, "onNode", getIdString(), Con::getIntArg(node)); Con::executef(mDataBlock, mSpline.getKnot(node)->mHitCommand.c_str(), getIdString()); } } //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- U32 PathShape::packUpdate(NetConnection *con, U32 mask, BitStream *stream) { Parent::packUpdate(con,mask,stream); if (stream->writeFlag(mask & StateMask)) stream->writeInt(mState,StateBits); if (stream->writeFlag(mask & PositionMask)) stream->write(mPosition); if (stream->writeFlag(mask & TargetMask)) if (stream->writeFlag(mTargetSet)) stream->write(mTarget); if (stream->writeFlag(mask & WindowMask)) { stream->write(mNodeBase); stream->write(mNodeCount); for (S32 i = 0; i < mNodeCount; i++) { CameraSpline::Knot *knot = mSpline.getKnot(i); mathWrite(*stream, knot->mPosition); mathWrite(*stream, knot->mRotation); stream->write(knot->mSpeed); stream->writeInt(knot->mType, CameraSpline::Knot::NUM_TYPE_BITS); stream->writeInt(knot->mPath, CameraSpline::Knot::NUM_PATH_BITS); } } // The rest of the data is part of the control object packet update. // If we're controlled by this client, we don't need to send it. if(stream->writeFlag(getControllingClient() == con && !(mask & InitialUpdateMask))) return 0; return 0; } void PathShape::unpackUpdate(NetConnection *con, BitStream *stream) { Parent::unpackUpdate(con,stream); // StateMask if (stream->readFlag()) mState = stream->readInt(StateBits); // PositionMask if (stream->readFlag()) { stream->read(&mPosition); delta.time = mPosition; delta.timeVec = 0; } // TargetMask if (stream->readFlag()) { mTargetSet = stream->readFlag(); if (mTargetSet) { stream->read(&mTarget); } } // WindowMask if (stream->readFlag()) { mSpline.removeAll(); stream->read(&mNodeBase); stream->read(&mNodeCount); for (S32 i = 0; i < mNodeCount; i++) { CameraSpline::Knot *knot = new CameraSpline::Knot(); mathRead(*stream, &knot->mPosition); mathRead(*stream, &knot->mRotation); stream->read(&knot->mSpeed); knot->mType = (CameraSpline::Knot::Type)stream->readInt(CameraSpline::Knot::NUM_TYPE_BITS); knot->mPath = (CameraSpline::Knot::Path)stream->readInt(CameraSpline::Knot::NUM_PATH_BITS); mSpline.push_back(knot); } } // Controlled by the client? if (stream->readFlag()) return; } //----------------------------------------------------------------------------- // Console access methods //----------------------------------------------------------------------------- DefineEngineMethod(PathShape, setPosition, void, (F32 position), (0.0f), "Set the current position of the camera along the path.\n" "@param position Position along the path, from 0.0 (path start) - 1.0 (path end), to place the camera.\n" "@tsexample\n" "// Set the camera on a position along its path from 0.0 - 1.0.\n" "%position = \"0.35\";\n\n" "// Force the pathCamera to its new position along the path.\n" "%pathCamera.setPosition(%position);\n" "@endtsexample\n") { object->setPosition(position); } DefineEngineMethod(PathShape, setTarget, void, (F32 position), (1.0f), "@brief Set the movement target for this camera along its path.\n\n" "The camera will attempt to move along the path to the given target in the direction provided " "by setState() (the default is forwards). Once the camera moves past this target it will come " "to a stop, and the target state will be cleared.\n" "@param position Target position, between 0.0 (path start) and 1.0 (path end), for the camera to move to along its path.\n" "@tsexample\n" "// Set the position target, between 0.0 (path start) and 1.0 (path end), for this camera to move to.\n" "%position = \"0.50\";\n\n" "// Inform the pathCamera of the new target position it will move to.\n" "%pathCamera.setTarget(%position);\n" "@endtsexample\n") { object->setTarget(position); } DefineEngineMethod(PathShape, setState, void, (const char* newState), ("forward"), "Set the movement state for this path camera.\n" "@param newState New movement state type for this camera. Forward, Backward or Stop.\n" "@tsexample\n" "// Set the state type (forward, backward, stop).\n" "// In this example, the camera will travel from the first node\n" "// to the last node (or target if given with setTarget())\n" "%state = \"forward\";\n\n" "// Inform the pathCamera to change its movement state to the defined value.\n" "%pathCamera.setState(%state);\n" "@endtsexample\n") { if (!dStricmp(newState, "forward")) object->setState(PathShape::Forward); else if (!dStricmp(newState, "backward")) object->setState(PathShape::Backward); else object->setState(PathShape::Stop); } DefineEngineMethod(PathShape, reset, void, (F32 speed), (1.0f), "@brief Clear the camera's path and set the camera's current transform as the start of the new path.\n\n" "What specifically occurs is a new knot is created from the camera's current transform. Then the current path " "is cleared and the new knot is pushed onto the path. Any previous target is cleared and the camera's movement " "state is set to Forward. The camera is now ready for a new path to be defined.\n" "@param speed Speed for the camera to move along its path after being reset.\n" "@tsexample\n" "//Determine the new movement speed of this camera. If not set, the speed will default to 1.0.\n" "%speed = \"0.50\";\n\n" "// Inform the path camera to start a new path at" "// the camera's current position, and set the new " "// path's speed value.\n" "%pathCamera.reset(%speed);\n" "@endtsexample\n") { object->reset(speed); } static CameraSpline::Knot::Type resolveKnotType(const char *arg) { if (dStricmp(arg, "Position Only") == 0) return CameraSpline::Knot::POSITION_ONLY; if (dStricmp(arg, "Kink") == 0) return CameraSpline::Knot::KINK; return CameraSpline::Knot::NORMAL; } static CameraSpline::Knot::Path resolveKnotPath(const char *arg) { if (!dStricmp(arg, "Linear")) return CameraSpline::Knot::LINEAR; return CameraSpline::Knot::SPLINE; } DefineEngineMethod(PathShape, pushBack, void, (TransformF transform, F32 speed, const char* type, const char* path, const char *hitCommand), (TransformF::Identity, 1.0f, "Normal", "Linear",""), "@brief Adds a new knot to the back of a path camera's path.\n" "@param transform Transform for the new knot. In the form of \"x y z ax ay az aa\" such as returned by SceneObject::getTransform()\n" "@param speed Speed setting for this knot.\n" "@param type Knot type (Normal, Position Only, Kink).\n" "@param path %Path type (Linear, Spline).\n" "@tsexample\n" "// Transform vector for new knot. (Pos_X Pos_Y Pos_Z Rot_X Rot_Y Rot_Z Angle)\n" "%transform = \"15.0 5.0 5.0 1.4 1.0 0.2 1.0\"\n\n" "// Speed setting for knot.\n" "%speed = \"1.0\"\n\n" "// Knot type. (Normal, Position Only, Kink)\n" "%type = \"Normal\";\n\n" "// Path Type. (Linear, Spline)\n" "%path = \"Linear\";\n\n" "// Inform the path camera to add a new knot to the back of its path\n" "%pathCamera.pushBack(%transform,%speed,%type,%path);\n" "@endtsexample\n") { QuatF rot(transform.getOrientation()); object->pushBack(new CameraSpline::Knot(transform.getPosition(), rot, speed, resolveKnotType(type), resolveKnotPath(path), String(hitCommand))); } DefineEngineMethod(PathShape, pushFront, void, (TransformF transform, F32 speed, const char* type, const char* path), (1.0f, "Normal", "Linear"), "@brief Adds a new knot to the front of a path camera's path.\n" "@param transform Transform for the new knot. In the form of \"x y z ax ay az aa\" such as returned by SceneObject::getTransform()\n" "@param speed Speed setting for this knot.\n" "@param type Knot type (Normal, Position Only, Kink).\n" "@param path %Path type (Linear, Spline).\n" "@tsexample\n" "// Transform vector for new knot. (Pos_X,Pos_Y,Pos_Z,Rot_X,Rot_Y,Rot_Z,Angle)\n" "%transform = \"15.0 5.0 5.0 1.4 1.0 0.2 1.0\"\n\n" "// Speed setting for knot.\n" "%speed = \"1.0\";\n\n" "// Knot type. (Normal, Position Only, Kink)\n" "%type = \"Normal\";\n\n" "// Path Type. (Linear, Spline)\n" "%path = \"Linear\";\n\n" "// Inform the path camera to add a new knot to the front of its path\n" "%pathCamera.pushFront(%transform, %speed, %type, %path);\n" "@endtsexample\n") { QuatF rot(transform.getOrientation()); object->pushFront(new CameraSpline::Knot(transform.getPosition(), rot, speed, resolveKnotType(type), resolveKnotPath(path))); } DefineEngineMethod(PathShape, popFront, void, (), , "Removes the knot at the front of the camera's path.\n" "@tsexample\n" "// Remove the first knot in the camera's path.\n" "%pathCamera.popFront();\n" "@endtsexample\n") { object->popFront(); } DefineEngineMethod(PathShape, getState, S32, (), , "PathShape.getState()") { return object->getState(); }