You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

188 lines
8.1 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#ifndef plCoordinateInterface_inc
#define plCoordinateInterface_inc
#include "plObjInterface.h"
#include "hsTemplates.h"
#include "hsMatrix44.h"
#include "pnNetCommon/plSynchedValue.h"
class hsStream;
class hsResMgr;
class plCoordinateInterface : public plObjInterface
{
public:
enum plCoordinateProperties {
kDisable = 0, // prop 0 is always disable, declared in plObjInterface
kCanEverDelayTransform = 1, // we can sometimes delay our transform eval (i.e. we're on a physics object)
kDelayedTransformEval = 2, // we're currently registering for the DelayedTransformMsg (we, and all our
// descendants, have the kCanEverDelayTransform prop)
kNumProps // last in the list
};
enum plCoordinateTransformPhases
{
kTransformPhaseNormal,
kTransformPhaseDelayed,
};
protected:
enum {
kTransformDirty = 0x1,
kWarp = 0x2,
kMaxState = 0xffff
};
enum plAttachFlags {
kMaintainWorldPosition = 0x1,
kMaintainSceneNode = 0x2,
kAboutToAttach = 0x4
};
enum Reason {
kReasonUnknown = 0x1, // somebody moved us
kReasonPhysics = 0x2, // physics moved us
kMaxReasons = 0xffff // sixteen bits
};
// Set by the client in IUpdate(). This tells us where we are in the update loop so that we know
// which transform message to register for when our transform is dirtied.
static UInt8 fTransformPhase;
// Temp debugging tool, so we can quickly (dis/en)able delayed transforms at runtime.
static hsBool fDelayedTransformsEnabled;
UInt16 fState;
UInt16 fReason; // why we've changed position (if we have)
hsTArray<plSceneObject*> fChildren;
plCoordinateInterface* fParent; // if this changes, marks us as dirty
hsMatrix44 fLocalToParent;
hsMatrix44 fParentToLocal;
hsMatrix44 fLocalToWorld;
hsMatrix44 fWorldToLocal;
virtual void ISetOwner(plSceneObject* so);
virtual void ISetParent(plCoordinateInterface* par); // don't use, use AddChild on parent
virtual void ISetSceneNode(plKey newNode);
// objectToo moves the sceneObject to the new room, else just move the data and remove
// the object from whatever room he's in.
// Network only strange functions. Do not emulate or generalize this functionality.
void ISetNetGroupRecur(plNetGroupId netGroup);
virtual void ISetChild(plSceneObject* child, int which); // sets parent on child
virtual void IAddChild(plSceneObject* child); // sets parent on child
virtual void IRemoveChild(plSceneObject* child); // removes this as parent of child
virtual void IRemoveChild(int i); // removes this as parent of child
virtual void IAttachChild(plSceneObject* child, UInt8 flags); // physically attaches child to us
virtual void IDetachChild(plSceneObject* child, UInt8 flags); // physically detach this child from us
virtual void IUpdateDelayProp(); // Called whenever a child is added/removed
virtual void IRecalcTransforms(); // Called by ITransformChanged when we need to re-examine our relationship with our parent.
virtual void ITransformChanged(hsBool force, UInt16 reasons, hsBool checkForDelay); // called by SceneObject on TransformChanged messsage
void IDirtyTransform();
void IRegisterForTransformMessage(hsBool delayed);
void IUnRegisterForTransformMessage();
plCoordinateInterface* IGetRoot();
friend class plSceneObject;
public:
plCoordinateInterface();
~plCoordinateInterface();
CLASSNAME_REGISTER( plCoordinateInterface );
GETINTERFACE_ANY( plCoordinateInterface, plObjInterface );
virtual void Read(hsStream* stream, hsResMgr* mgr);
virtual void Write(hsStream* stream, hsResMgr* mgr);
virtual void SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l);
virtual void SetLocalToParent(const hsMatrix44& l2p, const hsMatrix44& p2l);
// special version for setting transform from physics.
// separate to keep from changing interface to add "reason" parameter
virtual void SetTransformPhysical(const hsMatrix44& l2w, const hsMatrix44& w2l);
virtual void MultTransformLocal(const hsMatrix44& move, const hsMatrix44& invMove);
virtual void WarpToWorld(const hsMatrix44& l2w, const hsMatrix44& w2l);
virtual void WarpToLocal(const hsMatrix44& l2p, const hsMatrix44& p2l);
// Force an immediate re-sync of the transforms in the hierarchy this object belongs to,
// as opposed to waiting for the plTransformMsg to resync.
// There are two uses for this:
// a) You need the transforms for this object to be valid NOW, can't wait till after a TransforMsg
// In this case, you want to flush from the root, because something higher up the hierarchy
// may be dirty, which invalidates this object's transforms
// b) You've just dirtied this object's transform, and need it to propagate downward from here NOW
// In this case, fromRoot should be false, because you haven't dirtied anything higher up
// the hierarchy.
// Another way to look at it is, if the transforms for the tree were correct before you messed with
// this object, you only need to flush the transforms for this object and its recursive children,
// so fromRoot=false.
// If the entire tree is potentially dirty and you need to read from it, you want the entire tree
// synced up, so fromRoot=true.
// fromRoot=true is always safe, just potentially wasteful, so if you don't know, use fromRoot=true or
// preferably, don't use this function.
void FlushTransform(hsBool fromRoot=true);
virtual const hsMatrix44& GetLocalToParent() const { return fLocalToParent; }
virtual const hsMatrix44& GetParentToLocal() const { return fParentToLocal; }
virtual const hsMatrix44& GetLocalToWorld() const { return fLocalToWorld; }
virtual const hsMatrix44& GetWorldToLocal() const { return fWorldToLocal; }
virtual const hsPoint3 GetWorldPos() const { return fLocalToWorld.GetTranslate(); }
virtual int GetNumChildren() const { return fChildren.GetCount(); }
virtual plCoordinateInterface* GetChild(int i) const;
virtual plCoordinateInterface* GetParent() const { return fParent; }
virtual hsBool MsgReceive(plMessage* msg);
UInt16 GetReasons();
void ClearReasons();
Int32 GetNumProperties() const { return kNumProps; }
static UInt8 GetTransformPhase() { return fTransformPhase; }
static void SetTransformPhase(UInt8 phase) { fTransformPhase = phase; }
static hsBool GetDelayedTransformsEnabled() { return fDelayedTransformsEnabled; }
static void SetDelayedTransformsEnabled(hsBool val) { fDelayedTransformsEnabled = val; }
};
#endif // plCoordinateInterface_inc