TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-01-20 20:54:46 +00:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity
Torque3D/Engine/source/scene/sceneObject.cpp

1993 lines
58 KiB
C++
Raw Blame History

//-----------------------------------------------------------------------------
// 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.
//-----------------------------------------------------------------------------
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
// Arcane-FX for MIT Licensed Open Source version of Torque 3D from GarageGames
// Copyright (C) 2015 Faust Logic, Inc.
//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~//~~~~~~~~~~~~~~~~~~~~~//
#include "platform/platform.h"
#include "scene/sceneObject.h"
#include "platform/profiler.h"
#include "console/consoleTypes.h"
#include "console/engineAPI.h"
#include "console/simPersistID.h"
#include "sim/netConnection.h"
#include "core/stream/bitStream.h"
#include "scene/sceneManager.h"
#include "scene/sceneTracker.h"
#include "scene/sceneRenderState.h"
#include "scene/zones/sceneZoneSpace.h"
#include "collision/extrudedPolyList.h"
#include "collision/earlyOutPolyList.h"
#include "collision/optimizedPolyList.h"
#include "math/mPolyhedron.h"
#include "gfx/bitmap/gBitmap.h"
#include "math/util/frustum.h"
#include "math/mathIO.h"
#include "math/mTransform.h"
#include "T3D/gameBase/gameProcess.h"
#include "T3D/gameBase/gameConnection.h"
#include "T3D/accumulationVolume.h"
IMPLEMENT_CONOBJECT(SceneObject);
ConsoleDocClass( SceneObject,
"@brief A networkable object that exists in the 3D world.\n\n"
"The SceneObject class provides the foundation for 3D objects in the Engine. It "
"exposes the functionality for:\n\n"
"<ul><li>Position, rotation and scale within the world.</li>"
"<li>Working with a scene graph (in the Zone and Portal sections), allowing efficient "
"and robust rendering of the game scene.</li>"
"<li>Various helper functions, including functions to get bounding information "
"and momentum/velocity.</li>"
"<li>Mounting one SceneObject to another.</li>"
"<li>An interface for collision detection, as well as ray casting.</li>"
"<li>Lighting. SceneObjects can register lights both at lightmap generation "
"time, and dynamic lights at runtime (for special effects, such as from flame "
"or a projectile, or from an explosion).</li></ul>\n\n"
"You do not typically work with SceneObjects themselves. The SceneObject provides a reference "
"within the game world (the scene), but does not render to the client on its own. The "
"same is true of collision detection beyond that of the bounding box. Instead you "
"use one of the many classes that derrive from SceneObject, such as TSStatic.\n\n"
"@section SceneObject_Hiding Difference Between setHidden() and isRenderEnabled\n\n"
"When it comes time to decide if a SceneObject should render or not, there are two "
"methods that can stop the SceneObject from rendering at all. You need to be aware of "
"the differences between these two methods as they impact how the SceneObject is networked "
"from the server to the client.\n\n"
"The first method of manually controlling if a SceneObject is rendered is through its "
"SceneObject::isRenderEnabled property. When set to false the SceneObject is considered invisible but "
"still present within the scene. This means it still takes part in collisions and continues "
"to be networked.\n\n"
"The second method is using the setHidden() method. This will actually remove a SceneObject "
"from the scene and it will no longer be networked from the server to the cleint. Any client-side "
"ghost of the object will be deleted as the server no longer considers the object to be in scope.\n\n"
"@ingroup gameObjects\n"
);
IMPLEMENT_CALLBACK(SceneObject, onInspectPostApply, void, (SceneObject* obj), (obj),"Generic callback for when an object is edited");
#ifdef TORQUE_TOOLS
extern bool gEditingMission;
#endif
Signal< void( SceneObject* ) > SceneObject::smSceneObjectAdd;
Signal< void( SceneObject* ) > SceneObject::smSceneObjectRemove;
//-----------------------------------------------------------------------------
SceneObject::SceneObject()
{
mContainer = 0;
mTypeMask = DefaultObjectType;
mCollisionCount = 0;
mGlobalBounds = false;
mObjScale.set(1,1,1);
mObjToWorld.identity();
mWorldToObj.identity();
mObjBox = Box3F(Point3F(0, 0, 0), Point3F(0, 0, 0));
mWorldBox = Box3F(Point3F(0, 0, 0), Point3F(0, 0, 0));
mWorldSphere = SphereF(Point3F(0, 0, 0), 0);
mRenderObjToWorld.identity();
mRenderWorldToObj.identity();
mRenderWorldBox = Box3F(Point3F(0, 0, 0), Point3F(0, 0, 0));
mRenderWorldSphere = SphereF(Point3F(0, 0, 0), 0);
mContainerSeqKey = 0;
mBinRefHead = NULL;
mSceneManager = NULL;
mNumCurrZones = 0;
mZoneRefHead = NULL;
mZoneRefDirty = false;
mBinMinX = 0xFFFFFFFF;
mBinMaxX = 0xFFFFFFFF;
mBinMinY = 0xFFFFFFFF;
mBinMaxY = 0xFFFFFFFF;
mLightPlugin = NULL;
mMount.object = NULL;
mMount.link = NULL;
mMount.list = NULL;
mMount.node = -1;
mMount.xfm = MatrixF::Identity;
mMountPID = NULL;
mSceneObjectLinks = NULL;
mObjectFlags.set( RenderEnabledFlag | SelectionEnabledFlag );
// PATHSHAPE
// init the scenegraph relationships to indicate no parent, no children, and no siblings
mGraph.parent = NULL;
mGraph.nextSibling = NULL;
mGraph.firstChild = NULL;
mGraph.objToParent.identity();
// PATHSHAPE END
mIsScopeAlways = false;
mAccuTex = NULL;
mSelectionFlags = 0;
mPathfindingIgnore = false;
mGameObjectAssetId = StringTable->insert("");
mDirtyGameObject = false;
}
//-----------------------------------------------------------------------------
SceneObject::~SceneObject()
{
AssertFatal( mZoneRefHead == NULL && mBinRefHead == NULL,
"SceneObject::~SceneObject - Object still linked in reference lists!");
AssertFatal( !mSceneObjectLinks,
"SceneObject::~SceneObject() - object is still linked to SceneTrackers" );
mAccuTex = NULL;
unlink();
}
//-----------------------------------------------------------------------------
bool SceneObject::castRayRendered(const Point3F &start, const Point3F &end, RayInfo *info)
{
// By default, all ray checking against the rendered mesh will be passed
// on to the collision mesh. This saves having to define both methods
// for simple objects.
return castRay( start, end, info );
}
//-----------------------------------------------------------------------------
bool SceneObject::containsPoint( const Point3F& point )
{
// If it's not in the AABB, then it can't be in the OBB either,
// so early out.
if( !mWorldBox.isContained( point ) )
return false;
// Transform point into object space and test it against
// our object space bounding box.
Point3F objPoint( 0, 0, 0 );
getWorldTransform().mulP( point, &objPoint );
objPoint.convolveInverse( getScale() );
return ( mObjBox.isContained( objPoint ) );
}
//-----------------------------------------------------------------------------
bool SceneObject::collideBox(const Point3F &start, const Point3F &end, RayInfo *info)
{
const F32 * pStart = (const F32*)start;
const F32 * pEnd = (const F32*)end;
const F32 * pMin = (const F32*)mObjBox.minExtents;
const F32 * pMax = (const F32*)mObjBox.maxExtents;
F32 maxStartTime = -1;
F32 minEndTime = 1;
F32 startTime;
F32 endTime;
// used for getting normal
U32 hitIndex = 0xFFFFFFFF;
U32 side;
// walk the axis
for(U32 i = 0; i < 3; i++)
{
//
if(pStart[i] < pEnd[i])
{
if(pEnd[i] < pMin[i] || pStart[i] > pMax[i])
return(false);
F32 dist = pEnd[i] - pStart[i];
startTime = (pStart[i] < pMin[i]) ? (pMin[i] - pStart[i]) / dist : -1;
endTime = (pEnd[i] > pMax[i]) ? (pMax[i] - pStart[i]) / dist : 1;
side = 1;
}
else
{
if(pStart[i] < pMin[i] || pEnd[i] > pMax[i])
return(false);
F32 dist = pStart[i] - pEnd[i];
startTime = (pStart[i] > pMax[i]) ? (pStart[i] - pMax[i]) / dist : -1;
endTime = (pEnd[i] < pMin[i]) ? (pStart[i] - pMin[i]) / dist : 1;
side = 0;
}
//
if(startTime > maxStartTime)
{
maxStartTime = startTime;
hitIndex = i * 2 + side;
}
if(endTime < minEndTime)
minEndTime = endTime;
if(minEndTime < maxStartTime)
return(false);
}
// fail if inside
if(maxStartTime < 0.f)
return(false);
//
static Point3F boxNormals[] = {
Point3F( 1, 0, 0),
Point3F(-1, 0, 0),
Point3F( 0, 1, 0),
Point3F( 0,-1, 0),
Point3F( 0, 0, 1),
Point3F( 0, 0,-1),
};
//
AssertFatal(hitIndex != 0xFFFFFFFF, "SceneObject::collideBox");
info->t = maxStartTime;
info->object = this;
mObjToWorld.mulV(boxNormals[hitIndex], &info->normal);
info->material = 0;
return(true);
}
//-----------------------------------------------------------------------------
void SceneObject::disableCollision()
{
mCollisionCount++;
AssertFatal(mCollisionCount < 50, "SceneObject::disableCollision called 50 times on the same object. Is this inside a circular loop?" );
}
//-----------------------------------------------------------------------------
void SceneObject::enableCollision()
{
if (mCollisionCount)
--mCollisionCount;
}
//-----------------------------------------------------------------------------
bool SceneObject::onAdd()
{
if ( !Parent::onAdd() )
return false;
mIsScopeAlways = mNetFlags.test( ScopeAlways );
mWorldToObj = mObjToWorld;
mWorldToObj.affineInverse();
resetWorldBox();
setRenderTransform(mObjToWorld);
resolveMountPID();
smSceneObjectAdd.trigger(this);
return true;
}
//-----------------------------------------------------------------------------
void SceneObject::onRemove()
{
smSceneObjectRemove.trigger(this);
unmount();
plUnlink();
Parent::onRemove();
// PATHSHAPE
if ( getParent() != NULL) attachToParent( NULL);
// PATHSHAPE END
}
//-----------------------------------------------------------------------------
void SceneObject::addToScene()
{
if( mSceneManager )
return;
if( isClientObject() )
gClientSceneGraph->addObjectToScene( this );
else
gServerSceneGraph->addObjectToScene( this );
}
//-----------------------------------------------------------------------------
void SceneObject::removeFromScene()
{
if( !mSceneManager )
return;
mSceneManager->removeObjectFromScene( this );
}
//-----------------------------------------------------------------------------
void SceneObject::onDeleteNotify( SimObject *obj )
{
// We are comparing memory addresses so even if obj really is not a
// ProcessObject this cast shouldn't break anything.
if ( obj == mAfterObject )
mAfterObject = NULL;
if ( obj == mMount.object )
unmount();
Parent::onDeleteNotify( obj );
}
//-----------------------------------------------------------------------------
void SceneObject::inspectPostApply()
{
if( isServerObject() )
setMaskBits( MountedMask );
onInspectPostApply_callback(this);
Parent::inspectPostApply();
}
//-----------------------------------------------------------------------------
void SceneObject::setGlobalBounds()
{
mGlobalBounds = true;
mObjBox.minExtents.set( -1e10, -1e10, -1e10 );
mObjBox.maxExtents.set( 1e10, 1e10, 1e10 );
if( mSceneManager )
mSceneManager->notifyObjectDirty( this );
}
//-----------------------------------------------------------------------------
void SceneObject::setTransform( const MatrixF& mat )
{
// This test is a bit expensive so turn it off in release.
#ifdef TORQUE_DEBUG
//AssertFatal( mat.isAffine(), "SceneObject::setTransform() - Bad transform (non affine)!" );
#endif
PROFILE_SCOPE( SceneObject_setTransform );
// PATHSHAPE
PerformUpdatesForChildren(mat);
// PATHSHAPE END
// Update the transforms.
mObjToWorld = mWorldToObj = mat;
mWorldToObj.affineInverse();
// Update the world-space AABB.
resetWorldBox();
// If we're in a SceneManager, sync our scene state.
if( mSceneManager != NULL )
mSceneManager->notifyObjectDirty( this );
setRenderTransform( mat );
}
//-----------------------------------------------------------------------------
void SceneObject::setScale( const VectorF &scale )
{
AssertFatal( !mIsNaN( scale ), "SceneObject::setScale() - The scale is NaN!" );
// Avoid unnecessary scaling operations.
if ( mObjScale.equal( scale ) )
return;
mObjScale = scale;
setTransform(MatrixF(mObjToWorld));
// Make sure that any subclasses of me get a chance to react to the
// scale being changed.
onScaleChanged();
setMaskBits( ScaleMask );
}
void SceneObject::setForwardVector(VectorF newForward, VectorF upVector)
{
MatrixF mat = getTransform();
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("SceneObject::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);
setTransform(mat);
}
//-----------------------------------------------------------------------------
void SceneObject::resetWorldBox()
{
AssertFatal(mObjBox.isValidBox(), "SceneObject::resetWorldBox - Bad object box!");
mWorldBox = mObjBox;
mWorldBox.minExtents.convolve(mObjScale);
mWorldBox.maxExtents.convolve(mObjScale);
mObjToWorld.mul(mWorldBox);
AssertFatal(mWorldBox.isValidBox(), "SceneObject::resetWorldBox - Bad world box!");
// Create mWorldSphere from mWorldBox
mWorldBox.getCenter(&mWorldSphere.center);
mWorldSphere.radius = (mWorldBox.maxExtents - mWorldSphere.center).len();
// Update tracker links.
for( SceneObjectLink* link = mSceneObjectLinks; link != NULL;
link = link->getNextLink() )
link->update();
}
//-----------------------------------------------------------------------------
void SceneObject::resetObjectBox()
{
AssertFatal( mWorldBox.isValidBox(), "SceneObject::resetObjectBox - Bad world box!" );
mObjBox = mWorldBox;
mWorldToObj.mul( mObjBox );
Point3F objScale( mObjScale );
objScale.setMax( Point3F( (F32)POINT_EPSILON, (F32)POINT_EPSILON, (F32)POINT_EPSILON ) );
mObjBox.minExtents.convolveInverse( objScale );
mObjBox.maxExtents.convolveInverse( objScale );
AssertFatal( mObjBox.isValidBox(), "SceneObject::resetObjectBox - Bad object box!" );
// Update the mWorldSphere from mWorldBox
mWorldBox.getCenter( &mWorldSphere.center );
mWorldSphere.radius = ( mWorldBox.maxExtents - mWorldSphere.center ).len();
// Update scene managers.
for( SceneObjectLink* link = mSceneObjectLinks; link != NULL;
link = link->getNextLink() )
link->update();
}
//-----------------------------------------------------------------------------
void SceneObject::setRenderTransform(const MatrixF& mat)
{
PROFILE_START(SceneObj_setRenderTransform);
mRenderObjToWorld = mRenderWorldToObj = mat;
mRenderWorldToObj.affineInverse();
AssertFatal(mObjBox.isValidBox(), "Bad object box!");
resetRenderWorldBox();
PROFILE_END();
}
//-----------------------------------------------------------------------------
void SceneObject::resetRenderWorldBox()
{
AssertFatal( mObjBox.isValidBox(), "Bad object box!" );
mRenderWorldBox = mObjBox;
mRenderWorldBox.minExtents.convolve( mObjScale );
mRenderWorldBox.maxExtents.convolve( mObjScale );
mRenderObjToWorld.mul( mRenderWorldBox );
AssertFatal( mRenderWorldBox.isValidBox(), "Bad world box!" );
// Create mRenderWorldSphere from mRenderWorldBox.
mRenderWorldBox.getCenter( &mRenderWorldSphere.center );
mRenderWorldSphere.radius = ( mRenderWorldBox.maxExtents - mRenderWorldSphere.center ).len();
}
//-----------------------------------------------------------------------------
void SceneObject::setHidden( bool hidden )
{
if( hidden != isHidden() )
{
// Add/remove the object from the scene. Removing it
// will also cause the NetObject to go out of scope since
// the container query will not find it anymore. However,
// ScopeAlways objects need to be treated separately as we
// do next.
if( !hidden )
addToScene();
else
removeFromScene();
// ScopeAlways objects stay in scope no matter what, i.e. even
// if they aren't in the scene query anymore. So, to force ghosts
// to go away, we need to clear ScopeAlways while we are hidden.
if( hidden && mIsScopeAlways )
clearScopeAlways();
else if( !hidden && mIsScopeAlways )
setScopeAlways();
Parent::setHidden( hidden );
}
}
//-----------------------------------------------------------------------------
void SceneObject::initPersistFields()
{
addGroup("GameObject");
addField("GameObject", TypeGameObjectAssetPtr, Offset(mGameObjectAsset, SceneObject), "The asset Id used for the game object this entity is based on.");
addField("dirtyGameObject", TypeBool, Offset(mDirtyGameObject, SceneObject), "If this entity is a GameObject, it flags if this instance delinates from the template.",
AbstractClassRep::FieldFlags::FIELD_HideInInspectors);
endGroup("GameObject");
addGroup( "Transform" );
addProtectedField( "position", TypeMatrixPosition, Offset( mObjToWorld, SceneObject ),
&_setFieldPosition, &defaultProtectedGetFn,
"Object world position." );
addProtectedField( "rotation", TypeMatrixRotation, Offset( mObjToWorld, SceneObject ),
&_setFieldRotation, &defaultProtectedGetFn,
"Object world orientation." );
addProtectedField( "scale", TypePoint3F, Offset( mObjScale, SceneObject ),
&_setFieldScale, &defaultProtectedGetFn,
"Object world scale." );
endGroup( "Transform" );
addGroup( "Editing" );
addProtectedField( "isRenderEnabled", TypeBool, Offset( mObjectFlags, SceneObject ),
&_setRenderEnabled, &_getRenderEnabled,
"Controls client-side rendering of the object.\n"
"@see isRenderable()\n" );
addProtectedField( "isSelectionEnabled", TypeBool, Offset( mObjectFlags, SceneObject ),
&_setSelectionEnabled, &_getSelectionEnabled,
"Determines if the object may be selected from wihin the Tools.\n"
"@see isSelectable()\n" );
endGroup( "Editing" );
addGroup( "Mounting" );
addProtectedField( "mountPID", TypePID, Offset( mMountPID, SceneObject ), &_setMountPID, &defaultProtectedGetFn,
"@brief PersistentID of object we are mounted to.\n\n"
"Unlike the SimObjectID that is determined at run time, the PersistentID of an object is saved with the level/mission and "
"may be used to form a link between objects." );
addField( "mountNode", TypeS32, Offset( mMount.node, SceneObject ), "Node we are mounted to." );
addField( "mountPos", TypeMatrixPosition, Offset( mMount.xfm, SceneObject ), "Position we are mounted at ( object space of our mount object )." );
addField( "mountRot", TypeMatrixRotation, Offset( mMount.xfm, SceneObject ), "Rotation we are mounted at ( object space of our mount object )." );
endGroup( "Mounting" );
Parent::initPersistFields();
}
bool SceneObject::_setGameObject(void* object, const char* index, const char* data)
{
// Sanity!
AssertFatal(data != NULL, "Cannot use a NULL asset Id.");
return true; //rbI->setMeshAsset(data);
}
//-----------------------------------------------------------------------------
bool SceneObject::_setFieldPosition( void *object, const char *index, const char *data )
{
SceneObject* so = static_cast<SceneObject*>( object );
if ( so )
{
MatrixF txfm( so->getTransform() );
Con::setData( TypeMatrixPosition, &txfm, 0, 1, &data );
so->setTransform( txfm );
}
return false;
}
//-----------------------------------------------------------------------------
bool SceneObject::_setFieldRotation( void *object, const char *index, const char *data )
{
SceneObject* so = static_cast<SceneObject*>( object );
if ( so )
{
MatrixF txfm( so->getTransform() );
Con::setData( TypeMatrixRotation, &txfm, 0, 1, &data );
so->setTransform( txfm );
}
return false;
}
//-----------------------------------------------------------------------------
bool SceneObject::_setFieldScale( void *object, const char *index, const char *data )
{
SceneObject* so = static_cast<SceneObject*>( object );
if ( so )
{
Point3F scale;
Con::setData( TypePoint3F, &scale, 0, 1, &data );
so->setScale( scale );
}
return false;
}
//-----------------------------------------------------------------------------
bool SceneObject::writeField( StringTableEntry fieldName, const char* value )
{
if( !Parent::writeField( fieldName, value ) )
return false;
static StringTableEntry sIsRenderEnabled = StringTable->insert( "isRenderEnabled" );
static StringTableEntry sIsSelectionEnabled = StringTable->insert( "isSelectionEnabled" );
static StringTableEntry sMountNode = StringTable->insert( "mountNode" );
static StringTableEntry sMountPos = StringTable->insert( "mountPos" );
static StringTableEntry sMountRot = StringTable->insert( "mountRot" );
// Don't write flag fields if they are at their default values.
if( fieldName == sIsRenderEnabled && dAtob( value ) )
return false;
else if( fieldName == sIsSelectionEnabled && dAtob( value ) )
return false;
else if ( mMountPID == NULL && ( fieldName == sMountNode ||
fieldName == sMountPos ||
fieldName == sMountRot ) )
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
static void scopeCallback( SceneObject* obj, void* conPtr )
{
NetConnection* ptr = reinterpret_cast< NetConnection* >( conPtr );
if( obj->isScopeable() )
ptr->objectInScope(obj);
}
void SceneObject::onCameraScopeQuery( NetConnection* connection, CameraScopeQuery* query )
{
SceneManager* sceneManager = getSceneManager();
GameConnection* conn = dynamic_cast<GameConnection*> (connection);
if (conn && (query->visibleDistance = conn->getVisibleGhostDistance()) == 0.0f)
if ((query->visibleDistance = sceneManager->getVisibleGhostDistance()) == 0.0f)
query->visibleDistance = sceneManager->getVisibleDistance();
// Object itself is in scope.
if( this->isScopeable() )
connection->objectInScope( this );
// If we're mounted to something, that object is in scope too.
if( isMounted() )
connection->objectInScope( mMount.object );
// If we're added to a scene graph, let the graph do the scene scoping.
// Otherwise just put everything in the server container in scope.
if( getSceneManager() )
getSceneManager()->scopeScene( query, connection );
else
gServerContainer.findObjects( 0xFFFFFFFF, scopeCallback, connection );
}
//-----------------------------------------------------------------------------
bool SceneObject::isRenderEnabled() const
{
#ifdef TORQUE_TOOLS
if (gEditingMission)
{
AbstractClassRep *classRep = getClassRep();
return (mObjectFlags.test(RenderEnabledFlag) && classRep->isRenderEnabled());
}
#endif
return (mObjectFlags.test(RenderEnabledFlag));
}
//-----------------------------------------------------------------------------
void SceneObject::setRenderEnabled( bool value )
{
if( value )
mObjectFlags.set( RenderEnabledFlag );
else
mObjectFlags.clear( RenderEnabledFlag );
setMaskBits( FlagMask );
}
//-----------------------------------------------------------------------------
const char* SceneObject::_getRenderEnabled( void* object, const char* data )
{
SceneObject* obj = reinterpret_cast< SceneObject* >( object );
if( obj->mObjectFlags.test( RenderEnabledFlag ) )
return "1";
else
return "0";
}
//-----------------------------------------------------------------------------
bool SceneObject::_setRenderEnabled( void *object, const char *index, const char *data )
{
SceneObject* obj = reinterpret_cast< SceneObject* >( object );
obj->setRenderEnabled( dAtob( data ) );
return false;
}
//-----------------------------------------------------------------------------
bool SceneObject::isSelectionEnabled() const
{
AbstractClassRep *classRep = getClassRep();
return ( mObjectFlags.test( SelectionEnabledFlag ) && classRep->isSelectionEnabled() );
}
//-----------------------------------------------------------------------------
void SceneObject::setSelectionEnabled( bool value )
{
if( value )
mObjectFlags.set( SelectionEnabledFlag );
else
mObjectFlags.clear( SelectionEnabledFlag );
// Not synchronized on network so don't set dirty bit.
}
//-----------------------------------------------------------------------------
const char* SceneObject::_getSelectionEnabled( void* object, const char* data )
{
SceneObject* obj = reinterpret_cast< SceneObject* >( object );
if( obj->mObjectFlags.test( SelectionEnabledFlag ) )
return "true";
else
return "false";
}
//-----------------------------------------------------------------------------
bool SceneObject::_setSelectionEnabled( void *object, const char *index, const char *data )
{
SceneObject* obj = reinterpret_cast< SceneObject* >( object );
obj->setSelectionEnabled( dAtob( data ) );
return false;
}
//--------------------------------------------------------------------------
U32 SceneObject::packUpdate( NetConnection* conn, U32 mask, BitStream* stream )
{
U32 retMask = Parent::packUpdate( conn, mask, stream );
if ( stream->writeFlag( mask & FlagMask ) )
stream->writeRangedU32( (U32)mObjectFlags, 0, getObjectFlagMax() );
// PATHSHAPE
//Begin attachment
retMask = 0; //retry mask
if (stream->writeFlag(getParent() != NULL)) {
stream->writeAffineTransform(mGraph.objToParent);
}
if (stream->writeFlag(mask & MountedMask))
{
// Check to see if we need to write an object ID
if (stream->writeFlag(mGraph.parent)) {
S32 t = conn->getGhostIndex(mGraph.parent);
// Check to see if we can actually ghost this...
if (t == -1) {
// Cant, try again later
retMask |= MountedMask;
stream->writeFlag(false);
}
else {
// Can, write it.
stream->writeFlag(true);
stream->writeRangedU32(U32(t), 0, NetConnection::MaxGhostCount);
stream->writeAffineTransform(mGraph.objToParent);
//Con::errorf("%d: sent mounted on %d", getId(), mGraph.parent->getId());
}
}
}
// End of Attachment
// PATHSHAPE END
if ( mask & MountedMask )
{
if ( mMount.object )
{
S32 gIndex = conn->getGhostIndex( mMount.object );
if ( stream->writeFlag( gIndex != -1 ) )
{
stream->writeFlag( true );
stream->writeInt( gIndex, NetConnection::GhostIdBitSize );
if ( stream->writeFlag( mMount.node != -1 ) )
stream->writeInt( mMount.node, NumMountPointBits );
mathWrite( *stream, mMount.xfm );
}
else
// Will have to try again later
retMask |= MountedMask;
}
else
// Unmount if this isn't the initial packet
if ( stream->writeFlag( !(mask & InitialUpdateMask) ) )
stream->writeFlag( false );
}
else
stream->writeFlag( false );
return retMask;
}
//-----------------------------------------------------------------------------
void SceneObject::unpackUpdate( NetConnection* conn, BitStream* stream )
{
Parent::unpackUpdate( conn, stream );
// FlagMask
if ( stream->readFlag() )
mObjectFlags = stream->readRangedU32( 0, getObjectFlagMax() );
// PATHSHAPE
// begin of attachment
if (stream->readFlag())
{
MatrixF m;
stream->readAffineTransform(&m);
mGraph.objToParent = m;
}
if (stream->readFlag())
{
// Check to see if we need to read an object ID
if (stream->readFlag())
{
// Check to see if we can actually ghost this...
if (stream->readFlag())
{
GameBase *newParent = static_cast<GameBase*>(conn->resolveGhost(stream->readRangedU32(0, NetConnection::MaxGhostCount)));
MatrixF m;
stream->readAffineTransform(&m);
if (getParent() != newParent)
{
clearProcessAfter();
processAfter(newParent);
}
attachToParent(newParent, &m);
//Con::errorf("%d: got mounted on %d", getId(), mParentObject->getId());
}
}
else
{
attachToParent(NULL);
}
}
// End of attachment
// PATHSHAPE END
// MountedMask
if ( stream->readFlag() )
{
if ( stream->readFlag() )
{
S32 gIndex = stream->readInt( NetConnection::GhostIdBitSize );
SceneObject* obj = dynamic_cast<SceneObject*>( conn->resolveGhost( gIndex ) );
S32 node = -1;
if ( stream->readFlag() ) // node != -1
node = stream->readInt( NumMountPointBits );
MatrixF xfm;
mathRead( *stream, &xfm );
if ( !obj )
{
conn->setLastError( "Invalid packet from server." );
return;
}
obj->mountObject( this, node, xfm );
}
else
unmount();
}
}
//-----------------------------------------------------------------------------
void SceneObject::_updateZoningState() const
{
if( mZoneRefDirty )
{
SceneZoneSpaceManager* manager = getSceneManager()->getZoneManager();
if( manager )
manager->updateObject( const_cast< SceneObject* >( this ) );
else
mZoneRefDirty = false;
}
}
//-----------------------------------------------------------------------------
U32 SceneObject::getCurrZone( const U32 index ) const
{
_updateZoningState();
// Not the most efficient way to do this, walking the list,
// but it's an uncommon call...
ZoneRef* walk = mZoneRefHead;
for( U32 i = 0; i < index; ++ i )
{
walk = walk->nextInObj;
AssertFatal( walk != NULL, "SceneObject::_getCurrZone - Too few object refs!" );
}
AssertFatal( walk != NULL, "SceneObject::_getCurrZone - Too few object refs!" );
return walk->zone;
}
//-----------------------------------------------------------------------------
Point3F SceneObject::getPosition() const
{
Point3F pos;
mObjToWorld.getColumn(3, &pos);
return pos;
}
//-----------------------------------------------------------------------------
Point3F SceneObject::getRenderPosition() const
{
Point3F pos;
mRenderObjToWorld.getColumn(3, &pos);
return pos;
}
//-----------------------------------------------------------------------------
void SceneObject::setPosition(const Point3F &pos)
{
AssertFatal( !mIsNaN( pos ), "SceneObject::setPosition() - The position is NaN!" );
MatrixF xform = mObjToWorld;
xform.setColumn(3, pos);
setTransform(xform);
}
//-----------------------------------------------------------------------------
F32 SceneObject::distanceTo(const Point3F &pnt) const
{
return mWorldBox.getDistanceToPoint( pnt );
}
//-----------------------------------------------------------------------------
void SceneObject::processAfter( ProcessObject *obj )
{
AssertFatal( dynamic_cast<SceneObject*>( obj ), "SceneObject::processAfter - Got non-SceneObject!" );
mAfterObject = (SceneObject*)obj;
if ( mAfterObject->mAfterObject == this )
mAfterObject->mAfterObject = NULL;
getProcessList()->markDirty();
}
//-----------------------------------------------------------------------------
void SceneObject::clearProcessAfter()
{
mAfterObject = NULL;
}
//-----------------------------------------------------------------------------
void SceneObject::setProcessTick( bool t )
{
if ( t == mProcessTick )
return;
if ( mProcessTick )
{
if ( !getMountedObjectCount() )
plUnlink(); // Only unlink if there is nothing mounted to us
mProcessTick = false;
}
else
{
// Just to be sure...
plUnlink();
getProcessList()->addObject( this );
mProcessTick = true;
}
}
//-----------------------------------------------------------------------------
ProcessList* SceneObject::getProcessList() const
{
if ( isClientObject() )
return ClientProcessList::get();
else
return ServerProcessList::get();
}
//-------------------------------------------------------------------------
bool SceneObject::isMounted()
{
resolveMountPID();
return mMount.object != NULL;
}
//-----------------------------------------------------------------------------
S32 SceneObject::getMountedObjectCount()
{
S32 count = 0;
for (SceneObject* itr = mMount.list; itr; itr = itr->mMount.link)
count++;
return count;
}
//-----------------------------------------------------------------------------
SceneObject* SceneObject::getMountedObject(S32 idx)
{
if (idx >= 0) {
S32 count = 0;
for (SceneObject* itr = mMount.list; itr; itr = itr->mMount.link)
if (count++ == idx)
return itr;
}
return NULL;
}
//-----------------------------------------------------------------------------
S32 SceneObject::getMountedObjectNode(S32 idx)
{
if (idx >= 0) {
S32 count = 0;
for (SceneObject* itr = mMount.list; itr; itr = itr->mMount.link)
if (count++ == idx)
return itr->mMount.node;
}
return -1;
}
//-----------------------------------------------------------------------------
SceneObject* SceneObject::getMountNodeObject(S32 node)
{
for (SceneObject* itr = mMount.list; itr; itr = itr->mMount.link)
if (itr->mMount.node == node)
return itr;
return NULL;
}
//-----------------------------------------------------------------------------
bool SceneObject::_setMountPID( void* object, const char* index, const char* data )
{
SceneObject* so = static_cast<SceneObject*>( object );
if ( so )
{
// Unmount old object (PID reference is released even if it had been resolved yet)
if ( so->mMountPID )
{
so->mMountPID->decRefCount();
so->mMountPID = NULL;
}
so->unmount();
// Get the new PID (new object will be mounted on demand)
Con::setData( TypePID, &so->mMountPID, 0, 1, &data );
if ( so->mMountPID )
so->mMountPID->incRefCount(); // Prevent PID from being deleted out from under us!
}
return false;
}
void SceneObject::resolveMountPID()
{
if ( mMountPID && !mMount.object )
{
SceneObject *obj = dynamic_cast< SceneObject* >( mMountPID->getObject() );
if ( obj )
obj->mountObject( this, mMount.node, mMount.xfm );
}
}
//-----------------------------------------------------------------------------
void SceneObject::mountObject( SceneObject *obj, S32 node, const MatrixF &xfm )
{
if ( obj->mMount.object == this )
{
// Already mounted to this
// So update our node and xfm which may have changed.
obj->mMount.node = node;
obj->mMount.xfm = xfm;
}
else
{
if ( obj->mMount.object )
obj->unmount();
obj->mMount.object = this;
obj->mMount.node = node;
obj->mMount.link = mMount.list;
obj->mMount.xfm = xfm;
mMount.list = obj;
// Assign PIDs to both objects
if ( isServerObject() )
{
obj->getOrCreatePersistentId();
if ( !obj->mMountPID )
{
obj->mMountPID = getOrCreatePersistentId();
obj->mMountPID->incRefCount();
}
}
obj->onMount( this, node );
}
}
//-----------------------------------------------------------------------------
void SceneObject::unmountObject( SceneObject *obj )
{
if ( obj->mMount.object == this )
{
// Find and unlink the object
for ( SceneObject **ptr = &mMount.list; *ptr; ptr = &(*ptr)->mMount.link )
{
if ( *ptr == obj )
{
*ptr = obj->mMount.link;
break;
}
}
obj->mMount.object = NULL;
obj->mMount.link = NULL;
if( obj->mMountPID != NULL ) // Only on server.
{
obj->mMountPID->decRefCount();
obj->mMountPID = NULL;
}
obj->onUnmount( this, obj->mMount.node );
}
}
//-----------------------------------------------------------------------------
void SceneObject::unmount()
{
if (mMount.object)
mMount.object->unmountObject(this);
}
//-----------------------------------------------------------------------------
void SceneObject::onMount( SceneObject *obj, S32 node )
{
deleteNotify( obj );
if ( !isGhost() )
{
setMaskBits( MountedMask );
//onMount_callback( node );
}
}
//-----------------------------------------------------------------------------
void SceneObject::onUnmount( SceneObject *obj, S32 node )
{
clearNotify(obj);
if ( !isGhost() )
{
setMaskBits( MountedMask );
//onUnmount_callback( node );
}
}
//-----------------------------------------------------------------------------
void SceneObject::getMountTransform( S32 index, const MatrixF &xfm, MatrixF *outMat )
{
MatrixF mountTransform( xfm );
const Point3F &scale = getScale();
Point3F position = mountTransform.getPosition();
position.convolve( scale );
mountTransform.setPosition( position );
outMat->mul( mObjToWorld, mountTransform );
}
//-----------------------------------------------------------------------------
void SceneObject::getRenderMountTransform( F32 delta, S32 index, const MatrixF &xfm, MatrixF *outMat )
{
MatrixF mountTransform( xfm );
const Point3F &scale = getScale();
Point3F position = mountTransform.getPosition();
position.convolve( scale );
mountTransform.setPosition( position );
outMat->mul( mRenderObjToWorld, mountTransform );
}
//=============================================================================
// Console API.
//=============================================================================
// MARK: ---- Console API ----
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getType, S32, (),,
"Return the type mask for this object.\n"
"@return The numeric type mask for the object." )
{
return object->getTypeMask();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, mountObject, bool,
( SceneObject* objB, S32 slot, TransformF txfm ), ( TransformF::Identity ),
"@brief Mount objB to this object at the desired slot with optional transform.\n\n"
"@param objB Object to mount onto us\n"
"@param slot Mount slot ID\n"
"@param txfm (optional) mount offset transform\n"
"@return true if successful, false if failed (objB is not valid)" )
{
if ( objB )
{
object->mountObject( objB, slot, txfm.getMatrix() );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, unmountObject, bool, ( SceneObject* target ),,
"@brief Unmount an object from ourselves.\n\n"
"@param target object to unmount\n"
"@return true if successful, false if failed\n" )
{
if ( target )
{
object->unmountObject(target);
return true;
}
return false;
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, unmount, void, (),,
"Unmount us from the currently mounted object if any.\n" )
{
object->unmount();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, isMounted, bool, (),,
"@brief Check if we are mounted to another object.\n\n"
"@return true if mounted to another object, false if not mounted." )
{
return object->isMounted();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getObjectMount, S32, (),,
"@brief Get the object we are mounted to.\n\n"
"@return the SimObjectID of the object we're mounted to, or 0 if not mounted." )
{
return object->isMounted()? object->getObjectMount()->getId(): 0;
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getMountedObjectCount, S32, (),,
"Get the number of objects mounted to us.\n"
"@return the number of mounted objects." )
{
return object->getMountedObjectCount();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getMountedObject, S32, ( S32 slot ),,
"Get the object mounted at a particular slot.\n"
"@param slot mount slot index to query\n"
"@return ID of the object mounted in the slot, or 0 if no object." )
{
SceneObject* mobj = object->getMountedObject( slot );
return mobj? mobj->getId(): 0;
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getMountedObjectNode, S32, ( S32 slot ),,
"@brief Get the mount node index of the object mounted at our given slot.\n\n"
"@param slot mount slot index to query\n"
"@return index of the mount node used by the object mounted in this slot." )
{
return object->getMountedObjectNode( slot );
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getMountNodeObject, S32, ( S32 node ),,
"@brief Get the object mounted at our given node index.\n\n"
"@param node mount node index to query\n"
"@return ID of the first object mounted at the node, or 0 if none found." )
{
SceneObject* mobj = object->getMountNodeObject( node );
return mobj? mobj->getId(): 0;
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getTransform, TransformF, (),,
"Get the object's transform.\n"
"@return the current transform of the object\n" )
{
return object->getTransform();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getInverseTransform, TransformF, (),,
"Get the object's inverse transform.\n"
"@return the inverse transform of the object\n" )
{
return object->getWorldTransform();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getPosition, Point3F, (),,
"Get the object's world position.\n"
"@return the current world position of the object\n" )
{
return object->getTransform().getPosition();
}
DefineEngineMethod( SceneObject, setPosition, void, (Point3F pos),,
"Set the object's world position.\n"
"@param pos the new world position of the object\n" )
{
return object->setPosition(pos);
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getEulerRotation, Point3F, (),,
"Get Euler rotation of this object.\n"
"@return the orientation of the object in the form of rotations around the "
"X, Y and Z axes in degrees.\n" )
{
Point3F euler = object->getTransform().toEuler();
// Convert to degrees.
euler.x = mRadToDeg( euler.x );
euler.y = mRadToDeg( euler.y );
euler.z = mRadToDeg( euler.z );
return euler;
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getForwardVector, VectorF, (),,
"Get the direction this object is facing.\n"
"@return a vector indicating the direction this object is facing.\n"
"@note This is the object's y axis." )
{
return object->getTransform().getForwardVector();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getRightVector, VectorF, (),,
"Get the right vector of the object.\n"
"@return a vector indicating the right direction of this object."
"@note This is the object's x axis." )
{
return object->getTransform().getRightVector();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getUpVector, VectorF, (),,
"Get the up vector of the object.\n"
"@return a vector indicating the up direction of this object."
"@note This is the object's z axis." )
{
return object->getTransform().getUpVector();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, setTransform, void, ( TransformF txfm ),,
"Set the object's transform (orientation and position)."
"@param txfm object transform to set" )
{
// PATHSHAPE
object->PerformUpdatesForChildren(txfm.getMatrix());
// PATHSHAPE END
if ( !txfm.hasRotation() )
object->setPosition( txfm.getPosition() );
else
object->setTransform( txfm.getMatrix() );
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getScale, Point3F, (),,
"Get the object's scale.\n"
"@return object scale as a Point3F" )
{
return object->getScale();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, setScale, void, ( Point3F scale ),,
"Set the object's scale.\n"
"@param scale object scale to set\n" )
{
object->setScale( scale );
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getWorldBox, Box3F, (),,
"Get the object's world bounding box.\n"
"@return six fields, two Point3Fs, containing the min and max points of the "
"worldbox." )
{
return object->getWorldBox();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getWorldBoxCenter, Point3F, (),,
"Get the center of the object's world bounding box.\n"
"@return the center of the world bounding box for this object." )
{
Point3F center;
object->getWorldBox().getCenter( &center );
return center;
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, getObjectBox, Box3F, (),,
"Get the object's bounding box (relative to the object's origin).\n"
"@return six fields, two Point3Fs, containing the min and max points of the "
"objectbox." )
{
return object->getObjBox();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( SceneObject, isGlobalBounds, bool, (),,
"Check if this object has a global bounds set.\n"
"If global bounds are set to be true, then the object is assumed to have an "
"infinitely large bounding box for collision and rendering purposes.\n"
"@return true if the object has a global bounds." )
{
return object->isGlobalBounds();
}
DefineEngineMethod(SceneObject, setForwardVector, void, (VectorF newForward, VectorF upVector), (VectorF(0, 0, 0), VectorF(0, 0, 1)),
"Sets the forward vector of a scene object, making it face Y+ along the new vector.\n"
"@param The new forward vector to set.\n"
"@param (Optional) The up vector to use to help orient the rotation.")
{
object->setForwardVector(newForward, upVector);
}
// PATHSHAPE
// Move RenderTransform by set amount
// no longer used
void SceneObject::moveRender(const Point3F &delta)
{
Point3F pos;
const MatrixF& tmat = getRenderTransform();
tmat.getColumn(3,&pos);
AngAxisF aa(tmat);
pos += delta;
MatrixF mat;
aa.setMatrix(&mat);
mat.setColumn(3,pos);
setRenderTransform(mat);
}
void SceneObject::PerformUpdatesForChildren(MatrixF mat){
UpdateXformChange(mat);
for (U32 i=0; i < getNumChildren(); i++) {
SceneObject *o = getChild(i);
o->updateChildTransform(); //update the position of the child object
}
}
// This function will move the players based on how much it's
// parent have moved
void SceneObject::updateChildTransform(){
if (getParent() != NULL){
MatrixF one;
MatrixF two;
MatrixF three;
MatrixF four;
MatrixF mat;
one= getTransform();
two = getParent()->getTransform();
one.affineInverse();
four.mul(two,one);
mat.mul(getParent()->mLastXform,getTransform());
setTransform(mat);
}
}
// This function will move the rendered image based on how much it's
// parent have moved since the processtick.
// For some reason the player object must be updated via it's GetRenderTransform seen below,
// Other objects seem to require getTransform() only
void SceneObject::updateRenderChangesByParent(){
if (getParent() != NULL){
MatrixF renderXform = getParent()->getRenderTransform();
MatrixF xform = getParent()->getTransform();
xform.affineInverse();
MatrixF offset;
offset.mul(renderXform, xform);
MatrixF mat;
//add the "offset" caused by the parents change, and add it to it's own
// This is needed by objects that update their own render transform thru interpolate tick
// Mostly for stationary objects.
if (getClassName() == "Player")
mat.mul(offset,getRenderTransform());
else
mat.mul(offset,getTransform());
setRenderTransform(mat);
}
}
//Ramen - Move Transform by set amount
//written by Anthony Lovell
void SceneObject::move(F32 x, F32 y, F32 z)
{
Point3F delta;
delta.x = x;
delta.y = y;
delta.z = z;
move(delta);
}
// move by a specified delta in root coordinate space
void SceneObject::move(const Point3F &delta)
{
Point3F pos;
const MatrixF& tmat = getTransform();
tmat.getColumn(3,&pos);
AngAxisF aa(tmat);
pos += delta;
MatrixF mat;
aa.setMatrix(&mat);
mat.setColumn(3,pos);
setTransform(mat);
}
//written by Anthony Lovell ----------------------------------------------------------
U32
SceneObject::getNumChildren() const
{
U32 num = 0;
for (SceneObject *cur = mGraph.firstChild; cur; cur = cur->mGraph.nextSibling)
num++;
return num;
}
//written by Anthony Lovell ----------------------------------------------------------
SceneObject *
SceneObject::getChild(U32 index) const
{
SceneObject *cur = mGraph.firstChild;
for (U32 i = 0;
cur && i < index;
i++)
cur = cur->mGraph.nextSibling;
return cur;
}
void SceneObject::UpdateXformChange(const MatrixF &mat){
// This function gets the difference between the Transform and current Render transform
// Used for Interpolation matching with the child objects who rely on this data.
MatrixF oldxform = getTransform();
oldxform.affineInverse();
mLastXform.mul(mat,oldxform);
}
//----------------------------------------------------------
bool
SceneObject::attachChildAt(SceneObject *subObject, MatrixF atThisOffset, S32 node)
{
AssertFatal(subObject, "attaching a null subObject");
AssertFatal(!isChildOf(subObject), "cyclic attachChild()");
bool b = subObject->attachToParent(this, &atThisOffset, node);
if (!b)
return false;
return true;
}
//----------------------------------------------------------
bool
SceneObject::attachChildAt(SceneObject *subObject, Point3F atThisPosition)
{
AssertFatal(subObject, "attaching a null subObject");
AssertFatal(!isChildOf(subObject), "cyclic attachChild()");
bool b = subObject->attachToParent(this);
if (!b)
return false;
subObject->mGraph.objToParent.setColumn(3, atThisPosition);
// calcTransformFromLocalTransform();
return true;
}
//----------------------------------------------------------
bool
SceneObject::attachChild(SceneObject *child)
{
AssertFatal(child, "attaching a null subObject");
AssertFatal(!isChildOf(child), "cyclic attachChild()");
return child->attachToParent(this);
}
//----------------------------------------------------------
/// returns a count of children plus their children, recursively
U32
SceneObject::getNumProgeny() const
{
U32 num = 0;
for (SceneObject *cur = mGraph.firstChild; cur; cur = cur->mGraph.nextSibling) {
num += 1 + cur->getNumProgeny();
}
return num;
}
DefineEngineMethod(SceneObject, getNumChildren, S32, (),, "returns number of direct child objects")
{
return object->getNumChildren();
}
DefineEngineMethod(SceneObject, getNumProgeny, S32, (),, "returns number of recursively-nested child objects")
{
return object->getNumProgeny();
}
DefineEngineMethod(SceneObject, getChild, S32, (S32 _index), (0), "getChild(S32 index) -- returns child SceneObject at given index")
{
SceneObject *s = object->getChild(_index);
return s ? s->getId() : 0;
}
DefineEngineMethod(SceneObject, attachChildAt, bool, (SceneObject* _subObject, MatrixF _offset, S32 _node), (nullAsType<SceneObject*>(), MatrixF::Identity, 0), "(SceneObject subObject, MatrixF offset, S32 offset)"
"Mount object to this one with the specified offset expressed in our coordinate space.")
{
if (_subObject != nullptr)
{
return object->attachChildAt(_subObject, _offset, _node);
}
else
{
Con::errorf("Couldn't addObject()!");
return false;
}
}
DefineEngineMethod(SceneObject, attachToParent, bool, (const char*_sceneObject), ,"attachToParent(SceneObject)"
"specify a null or non-null parent")
{
SceneObject * t;
if(Sim::findObject(_sceneObject, t))
{
return object->attachToParent(t);
}
else
{
if ((!dStrcmp("0", _sceneObject))|| (!dStrcmp("", _sceneObject)))
return object->attachToParent(NULL);
else
{
Con::errorf("Couldn't setParent()!");
return false;
}
}
}
DefineEngineMethod(SceneObject, getParent, S32, (),, "returns ID of parent SceneObject")
{
SceneObject *p = object->getParent();
return p ? p->getId() : -1;
}
DefineEngineMethod(SceneObject, attachChild, bool, (const char*_subObject),, "(SceneObject subObject)"
"attach an object to this one, preserving its present transform.")
{
SceneObject * t;
MatrixF m;
if(Sim::findObject(_subObject, t))
return object->attachChild(t);
Con::errorf("Couldn't addObject()!");
return false;
}
bool SceneObject::isChildOf(SceneObject *so)
{
SceneObject *p = mGraph.parent;
if (p) {
if (p == so)
return true;
else
return p->isChildOf(so);
} else
return false;
}
bool SceneObject::attachToParent(SceneObject *newParent, MatrixF *atThisOffset/* = NULL */, S32 node )
{
SceneObject *oldParent = mGraph.parent;
if (oldParent == newParent)
return true;
// cycles in the scene hierarchy are forbidden!
// that is: a SceneObject cannot be a child of its progeny
if (newParent && newParent->isChildOf(this))
return false;
mGraph.parent = newParent;
if (oldParent) {
clearNotify(oldParent);
// remove this SceneObject from the list of children of oldParent
SceneObject *cur = oldParent->mGraph.firstChild;
if (cur == this) { // if we are the first child, this is easy
oldParent->mGraph.firstChild = mGraph.nextSibling;
} else {
while (cur->mGraph.nextSibling != this) {
cur = cur->mGraph.nextSibling;
// ASSERT cur != NULL;
}
cur->mGraph.nextSibling = mGraph.nextSibling;
}
oldParent->onLostChild(this);
}
if (newParent) {
deleteNotify(newParent); // if we are deleted, inform our parent
// add this SceneObject to the list of children of oldParent
mGraph.nextSibling = newParent->mGraph.firstChild;
newParent->mGraph.firstChild = this;
mGraph.parent = newParent;
newParent->onNewChild(this);
if (atThisOffset)
mGraph.objToParent = *atThisOffset;
} else {
mGraph.parent = NULL;
mGraph.nextSibling = NULL;
mGraph.objToParent = mObjToWorld;
}
onLostParent(oldParent);
onNewParent(newParent);
setMaskBits(MountedMask);
return true;
}
DefineEngineMethod(SceneObject, detachChild, bool, (const char*_subObject),, "SceneObject subObject")
{
SceneObject * t;
if(Sim::findObject(_subObject, t)) {
return t->attachToParent(NULL);
} else
return false;
}
// subclasses can do something with these if they care to
void SceneObject::onNewParent(SceneObject *newParent) {}
void SceneObject::onLostParent(SceneObject *oldParent){}
void SceneObject::onNewChild(SceneObject *newKid){}
void SceneObject::onLostChild(SceneObject *lostKid){}
Reference in a new issue View git blame Copy permalink