/*!
Returns a unique id for \a object. Calling this method multiple times
for the same object will return the same id.
*/
int QDeclarativeDebugService::idForObject(QObject *object)
{
if (!object)
return -1;
ObjectReferenceHash *hash = objectReferenceHash();
QHash<QObject *, ObjectReference>::Iterator iter =
hash->objects.find(object);
if (iter == hash->objects.end()) {
int id = hash->nextId++;
hash->ids.insert(id, object);
iter = hash->objects.insert(object, ObjectReference());
iter->object = object;
iter->id = id;
} else if (iter->object != object) {
int id = hash->nextId++;
hash->ids.remove(iter->id);
hash->ids.insert(id, object);
iter->object = object;
iter->id = id;
}
return iter->id;
}
void OrphanLocUpdateManager::addOrphanUpdate(const SpaceObjectReference& observed, const Sirikata::Protocol::Loc::LocationUpdate& update) {
assert( ObjectReference(update.object()) == observed.object() );
UpdateInfoList& info_list = mUpdates[observed];
info_list.push_back(
UpdateInfoPtr(new UpdateInfo(observed, new Sirikata::Protocol::Loc::LocationUpdate(update), mContext->simTime() + mTimeout))
);
}
void CBRLocationServiceCache::physicsUpdated(const UUID& uuid, bool agg, const String& newval) {
mStrand->post(
std::tr1::bind(
&CBRLocationServiceCache::processPhysicsUpdated, this,
ObjectReference(uuid), agg, newval
),
"CBRLocationServiceCache::processPhysicsUpdated"
);
}
void CBRLocationServiceCache::boundsUpdated(const UUID& uuid, bool agg, const AggregateBoundingInfo& newval) {
mStrand->post(
std::tr1::bind(
&CBRLocationServiceCache::processBoundsUpdated, this,
ObjectReference(uuid), agg, newval
),
"CBRLocationServiceCache::processBoundsUpdated"
);
}
void CBRLocationServiceCache::orientationUpdated(const UUID& uuid, bool agg, const TimedMotionQuaternion& newval) {
mStrand->post(
std::tr1::bind(
&CBRLocationServiceCache::processOrientationUpdated, this,
ObjectReference(uuid), agg, newval
),
"CBRLocationServiceCache::processOrientationUpdated"
);
}
void CBRLocationServiceCache::objectRemoved(const UUID& uuid, bool agg) {
Lock lck(mDataMutex);
ObjectDataMap::iterator data_it = mObjects.find(ObjectReference(uuid));
if (data_it == mObjects.end()) return;
assert(data_it->second.exists);
data_it->second.exists = false;
data_it->second.tracking++;
mStrand->post(
std::tr1::bind(
&CBRLocationServiceCache::processObjectRemoved, this,
ObjectReference(uuid), agg
),
"CBRLocationServiceCache::processObjectRemoved"
);
}
bool decodeObjectReference(v8::Handle<v8::Value> toDecode, ObjectReference& oref, String& errorMessage)
{
String orefStr;
bool strDecode = decodeString(toDecode,orefStr,errorMessage);
if (! strDecode )
return false;
oref = ObjectReference(orefStr);
return true;
}
explicit SpaceObjectReference(const String& humanReadable) {
String::size_type where=humanReadable.find(":");
if (where==String::npos) {
mObject=ObjectReference::null();
mSpace=SpaceID::null();
throw std::invalid_argument("Unable to find colon separator in SpaceObjectReference");
} else {
mSpace=SpaceID(humanReadable.substr(0,where));
mObject=ObjectReference(humanReadable.substr(where+1));
}
}
void HostedObject::receiveMessage(const SpaceID& space, const Protocol::Object::ObjectMessage* msg) {
if (stopped()) {
HO_LOG(detailed,"Ignoring received message after system stop requested.");
return;
}
// Convert to ODP runtime format
ODP::Endpoint src_ep(space, ObjectReference(msg->source_object()), msg->source_port());
ODP::Endpoint dst_ep(space, ObjectReference(msg->dest_object()), msg->dest_port());
if (mDelegateODPService->deliver(src_ep, dst_ep, MemoryReference(msg->payload()))) {
// if this was true, it got delivered
delete msg;
}
else {
SILOG(cppoh,detailed,"[HO] Undelivered message from " << src_ep << " to " << dst_ep);
delete msg;
}
}
void HostedObject::handleLocationUpdate(const SpaceObjectReference& observer, const LocUpdate& lu) {
ProxyManagerPtr proxy_manager = this->getProxyManager(observer.space(), observer.object());
if (!proxy_manager) {
HO_LOG(warn,"Hosted Object received a message for a presence without a proxy manager.");
return;
}
SpaceObjectReference observed(observer.space(), ObjectReference(lu.object()));
ProxyObjectPtr proxy_obj = proxy_manager->getProxyObject(observed);
assert(proxy_obj);
this->processLocationUpdate( observer, proxy_obj, lu);
}
void CBRLocationServiceCache::objectAdded(const UUID& uuid, bool islocal, bool agg, const TimedMotionVector3f& loc, const TimedMotionQuaternion& orient, const AggregateBoundingInfo& bounds, const String& mesh, const String& phy, const String& zernike) {
// This looks a bit odd compared to some other similar methods. We check for
// and insert the object immediately because addPlaceholderImposter needs it
// to occur immediately (because imposters need to be added so they can be
// refcounted by the query events to ensure they stay alive in this cache as
// long as they are needed). TODO(ewencp) We should probably just make this
// look more like the other implementations of LocationServiceCache (using
// posting only to get notifications in the right strand) but who knows what
// kind of fallout that might have...
Lock lck(mDataMutex);
ObjectReference uuid_obj(uuid);
ObjectDataMap::iterator it = mObjects.find(uuid_obj);
// Construct for both since we'll pass it through the callback
ObjectData data;
data.location = loc;
data.orientation = orient;
data.bounds = bounds;
data.mesh = mesh;
data.physics = phy;
data.zernike = zernike;
data.isLocal = islocal;
data.exists = true;
data.tracking = 0;
data.isAggregate = agg;
if (it != mObjects.end()) {
// Mark as exists. It's important we do this since it may be the only
// thing that keeps this object alive as we may still be processing
// removals in the other strand.
it->second.exists = true;
}
else {
mObjects[uuid_obj] = data;
it = mObjects.find(uuid_obj);
}
it->second.tracking++;
mStrand->post(
std::tr1::bind(
&CBRLocationServiceCache::processObjectAdded, this,
ObjectReference(uuid), data
),
"CBRLocationServiceCache::processObjectAdded"
);
}
bool HostedObject::objectHostConnect(const SpaceID spaceID,
const Location startingLocation,
const BoundingSphere3f meshBounds,
const String mesh,
const String physics,
const String query,
const String zernike,
const ObjectReference orefID,
PresenceToken token)
{
ObjectReference oref = (orefID == ObjectReference::null()) ? ObjectReference(UUID::random()) : orefID;
SpaceObjectReference connectingSporef (spaceID,oref);
// Note: we always use Time::null() here. The server will fill in the
// appropriate value. When we get the callback, we can fix this up.
Time approx_server_time = Time::null();
if (mObjectHost->connect(
getSharedPtr(),
connectingSporef, spaceID,
TimedMotionVector3f(approx_server_time, MotionVector3f( Vector3f(startingLocation.getPosition()), startingLocation.getVelocity()) ),
TimedMotionQuaternion(approx_server_time,MotionQuaternion(startingLocation.getOrientation().normal(),Quaternion(startingLocation.getAxisOfRotation(),startingLocation.getAngularSpeed()))), //normalize orientations
meshBounds,
mesh,
physics,
query,
zernike,
std::tr1::bind(&HostedObject::handleConnected, getWeakPtr(), mObjectHost, _1, _2, _3),
std::tr1::bind(&HostedObject::handleMigrated, getWeakPtr(), _1, _2, _3),
std::tr1::bind(&HostedObject::handleStreamCreated, getWeakPtr(), _1, _2, token),
std::tr1::bind(&HostedObject::handleDisconnected, getWeakPtr(), _1, _2)
)) {
mObjectHost->registerHostedObject(connectingSporef,getSharedPtr());
return true;
}else {
return false;
}
}
virtual ObjectReference parent() const { return ObjectReference(mUpdate.parent()); }
/**
* Pass the ReturnedObjectConnection info,
* containing an Object UUID to the proximity manager,
* so the proximity system knows about a new object
*/
virtual ObjectReference newObj(const Sirikata::Protocol::IRetObj&iro,
const void *optionalSerializedReturnObjectConnection=NULL,
size_t optionalSerializedReturnObjectConnectionSize=0){
return ObjectReference(iro.object_reference());
//does nothing since the space is forwarding proximity messages with this bridge
}
void HostedObject::handleProximityUpdate(const SpaceObjectReference& spaceobj, const Sirikata::Protocol::Prox::ProximityUpdate& update) {
HostedObject* self = this;
SpaceID space = spaceobj.space();
ProxyManagerPtr proxy_manager = self->getProxyManager(spaceobj.space(),spaceobj.object());
if (!proxy_manager) {
HO_LOG(warn,"Hosted Object received a message for a presence without a proxy manager.");
return;
}
for(int32 aidx = 0; aidx < update.addition_size(); aidx++) {
Sirikata::Protocol::Prox::ObjectAddition addition = update.addition(aidx);
ProxProtocolLocUpdate add(addition);
SpaceObjectReference proximateID(spaceobj.space(), add.object());
TimedMotionVector3f loc(add.locationWithLocalTime(this, spaceobj.space()));
CONTEXT_OHTRACE(prox,
spaceobj.object().getAsUUID(),
//getUUID(),
addition.object(),
true,
loc
);
TimedMotionQuaternion orient(add.orientationWithLocalTime(this, spaceobj.space()));
BoundingSphere3f bnds = add.bounds();
String mesh = add.meshOrDefault();
String phy = add.physicsOrDefault();
bool isAggregate =
(addition.type() == Sirikata::Protocol::Prox::ObjectAddition::Aggregate) ?
true : false;
ProxyObjectPtr proxy_obj = proxy_manager->getProxyObject(proximateID);
if (!proxy_obj) {
Transfer::URI meshuri;
if (addition.has_mesh()) meshuri = Transfer::URI(addition.mesh());
// FIXME use weak_ptr instead of raw
uint64 proxyAddSeqNo = add.location_seqno();
assert( add.location_seqno() == add.orientation_seqno() &&
add.location_seqno() == add.bounds_seqno() &&
add.location_seqno() == add.mesh_seqno() &&
add.location_seqno() == add.physics_seqno());
proxy_obj = self->createProxy(proximateID, spaceobj, meshuri, loc, orient, bnds, phy, "",
isAggregate, proxyAddSeqNo);
}
else {
// We need to handle optional values properly -- they
// shouldn't get overwritten.
String* mesh_ptr = (addition.has_mesh() ? &mesh : NULL);
String* phy_ptr = (addition.has_physics() ? &phy : NULL);
self->processLocationUpdate(space, proxy_obj, false,
&loc, add.location_seqno(),
&orient, add.orientation_seqno(),
&bnds, add.bounds_seqno(),
mesh_ptr, add.mesh_seqno(),
phy_ptr, add.physics_seqno()
);
}
// Always mark the object as valid (either revalidated, or just
// valid for the first time)
if (proxy_obj) proxy_obj->validate();
//tells the object script that something that was close has come
//into view
if(self->mObjectScript)
self->mObjectScript->notifyProximate(proxy_obj,spaceobj);
}
for(int32 ridx = 0; ridx < update.removal_size(); ridx++) {
Sirikata::Protocol::Prox::ObjectRemoval removal = update.removal(ridx);
SpaceObjectReference removed_obj_ref(spaceobj.space(),
ObjectReference(removal.object()));
bool permanent = (removal.has_type() && (removal.type() == Sirikata::Protocol::Prox::ObjectRemoval::Permanent));
if (removed_obj_ref == spaceobj) {
// We want to ignore removal of ourself -- we should
// always be in our result set, and we don't want to
// delete our own proxy.
SILOG(oh,detailed,"Ignoring self removal from proximity results.");
}
else {
ProxyObjectPtr proxy_obj = proxy_manager->getProxyObject(removed_obj_ref);
if (proxy_obj) {
// NOTE: We *don't* reset the proxy object
// here. Resetting it puts the seqnos back at 0,
// but if we get an addition while still on this
// space server, we actually want the old ones to
// stay in place, in case of unordered prox/loc
// updates. Resetting only happens when we move
// across space servers (see handleMigrated).
proxy_manager->destroyObject(proxy_obj);
if (self->mObjectScript)
self->mObjectScript->notifyProximateGone(proxy_obj,spaceobj);
proxy_obj->invalidate(permanent);
}
}
CONTEXT_OHTRACE(prox,
spaceobj.object().getAsUUID(),
//getUUID(),
removal.object(),
false,
TimedMotionVector3f()
);
}
}
TSharedPtr<FMovieSceneAnimationSectionRecorder> UActorRecording::StartRecordingComponentProperties(const FName& BindingName, USceneComponent* SceneComponent, UObject* BindingContext, ULevelSequence* CurrentSequence, float CurrentSequenceTime, const FAnimationRecordingSettings& InAnimationSettings)
{
// first create a possessable for this component to be controlled by
UMovieScene* OwnerMovieScene = CurrentSequence->GetMovieScene();
const FGuid PossessableGuid = OwnerMovieScene->AddPossessable(BindingName.ToString(), SceneComponent->GetClass());
// Set up parent/child guids for possessables within spawnables
FMovieScenePossessable* ChildPossessable = OwnerMovieScene->FindPossessable(PossessableGuid);
if (ensure(ChildPossessable))
{
ChildPossessable->SetParent(Guid);
}
FMovieSceneSpawnable* ParentSpawnable = OwnerMovieScene->FindSpawnable(Guid);
if (ParentSpawnable)
{
ParentSpawnable->AddChildPossessable(PossessableGuid);
}
// BindingName must be the component's path relative to its owner Actor
FLevelSequenceObjectReference ObjectReference(FUniqueObjectGuid(), BindingName.ToString());
CurrentSequence->BindPossessableObject(PossessableGuid, ObjectReference);
// First try built-in animation recorder...
TSharedPtr<FMovieSceneAnimationSectionRecorder> AnimationRecorder = nullptr;
if (FSequenceRecorder::Get().GetAnimationRecorderFactory().CanRecordObject(SceneComponent))
{
AnimationRecorder = FSequenceRecorder::Get().GetAnimationRecorderFactory().CreateSectionRecorder(this, InAnimationSettings);
AnimationRecorder->CreateSection(SceneComponent, OwnerMovieScene, PossessableGuid, CurrentSequenceTime);
AnimationRecorder->Record(CurrentSequenceTime);
SectionRecorders.Add(AnimationRecorder);
}
// ...and transform...
if (FSequenceRecorder::Get().GetTransformRecorderFactory().CanRecordObject(SceneComponent))
{
TSharedPtr<IMovieSceneSectionRecorder> Recorder = FSequenceRecorder::Get().GetTransformRecorderFactory().CreateSectionRecorder(true, nullptr);
if (Recorder.IsValid())
{
Recorder->CreateSection(SceneComponent, OwnerMovieScene, PossessableGuid, CurrentSequenceTime);
Recorder->Record(CurrentSequenceTime);
SectionRecorders.Add(Recorder);
}
}
// ...now any external recorders
TArray<IMovieSceneSectionRecorderFactory*> ModularFeatures = IModularFeatures::Get().GetModularFeatureImplementations<IMovieSceneSectionRecorderFactory>(MovieSceneSectionRecorderFactoryName);
for (IMovieSceneSectionRecorderFactory* Factory : ModularFeatures)
{
if (Factory->CanRecordObject(SceneComponent))
{
TSharedPtr<IMovieSceneSectionRecorder> Recorder = Factory->CreateSectionRecorder(ActorSettings);
if (Recorder.IsValid())
{
Recorder->CreateSection(SceneComponent, OwnerMovieScene, PossessableGuid, CurrentSequenceTime);
Recorder->Record(CurrentSequenceTime);
SectionRecorders.Add(Recorder);
}
}
}
return AnimationRecorder;
}
