FOnlineAsyncMsgSteam* FOnlineAsyncMsgSteam::Serialize(AActor* Actor, UFunction* Function, void* Params)
{
// Allocate the message buffer
MessagePoolElem* Msg = GProtoPool.GetNextFree(Function);
// Allocate the response buffer if necessary
MessagePoolElem* ResponseMsg = NULL;
if (Function->RPCResponseId > 0)
{
UFunction* ResponseFunction = FindNetServiceFunctionById(Function->RPCResponseId);
ResponseMsg = GProtoPool.GetNextFree(ResponseFunction);
}
google::protobuf::Message* NewMessage = (*Msg)->Msg;
if (NewMessage && SerializeRPCParams(NewMessage, Function, Params, CPF_Parm))
{
TWeakObjectPtr<AActor> ActorPtr(Actor);
return new FOnlineAsyncMsgSteam(ActorPtr, Function->RPCId, Function->RPCResponseId, Msg, ResponseMsg);
}
else
{
GProtoPool.ReturnToPool(Msg);
GProtoPool.ReturnToPool(ResponseMsg);
}
return NULL;
}
ActorPtr ActorSet::getPtr(OBJECT_ID id)
{
if(isMember(id))
return(actors.find(id)->second);
else
return ActorPtr();
}
ActorPtr Actor::forPid(int pid)
{
smx_actor_t process = SIMIX_process_from_PID(pid);
if (process != nullptr)
return ActorPtr(&process->getIface());
else
return nullptr;
}
void GDynamicActor::RenderExtra( dword dwOption )
{
if( !m_aOrnamentExtra.empty() ) GrpSuper::RenderOrnament( ORO_EXTRALOOP );
if( m_bVolatileRenderExtraFlag )
{
m_bVolatileRenderExtraFlag = false;
}
// Render Children
for( int iAtt=0; iAtt<m_aAttachedActor.Num(); iAtt++ )
{
DActor *pActor = ActorPtr( m_aAttachedActor[iAtt] );
if( pActor ) pActor->Render( ARO_EXTRA );
}
// Render Shadow
RenderShadow();
}
void FLevelScriptEventMenuHelper::FillLevelBlueprintEventsMenu(class FMenuBuilder& MenuBuilder, const TArray<AActor*>& SelectedActors)
{
AActor* SelectedActor = (1 == SelectedActors.Num()) ? SelectedActors[0] : NULL;
if (FKismetEditorUtilities::IsActorValidForLevelScript(SelectedActor))
{
const bool bAnyEventExists = FKismetEditorUtilities::AnyBoundLevelScriptEventForActor(SelectedActor, false);
const bool bAnyEventCanBeAdded = FKismetEditorUtilities::AnyBoundLevelScriptEventForActor(SelectedActor, true);
if (bAnyEventExists || bAnyEventCanBeAdded)
{
TWeakObjectPtr<AActor> ActorPtr(SelectedActor);
MenuBuilder.BeginSection("LevelBlueprintEvents", LOCTEXT("LevelBlueprintEvents", "Level Blueprint Events"));
if (bAnyEventExists)
{
MenuBuilder.AddSubMenu(
LOCTEXT("JumpEventSubMenu", "Jump to Event"),
FText::GetEmpty(),
FNewMenuDelegate::CreateStatic(&FKismetEditorUtilities::AddLevelScriptEventOptionsForActor
, ActorPtr
, true
, false
, true));
}
if (bAnyEventCanBeAdded)
{
MenuBuilder.AddSubMenu(
LOCTEXT("AddEventSubMenu", "Add Event"),
FText::GetEmpty(),
FNewMenuDelegate::CreateStatic(&FKismetEditorUtilities::AddLevelScriptEventOptionsForActor
, ActorPtr
, false
, true
, true));
}
MenuBuilder.EndSection();
}
}
}
/** @brief get the receiver (process associated to the mailbox) */
ActorPtr Mailbox::get_receiver()
{
if (pimpl_->permanent_receiver == nullptr)
return ActorPtr();
return pimpl_->permanent_receiver->iface();
}
void ActorSerializer::DeserializeActor(std::istream& stream, std::vector<ActorPtr>& actors)
{
if (!stream)
throw Commons::IOException("Stream is not opened");
ActorPtr curActor;
int32_t curLevel = 0;
BigEndianStreamReader reader(stream);
FileHeaderChunk fileHeader;
ChunkHeader header;
while (!reader.isEOF())
{
header.read(reader);
uint32_t lastOffset = reader.tell();
if (header.getMagic() == FileHeaderChunk::MAGIC)
{
fileHeader.read(reader);
}
else if (header.getMagic() == ActorNameChunk::MAGIC)
{
curActor = ActorPtr(new Actor());
assert(curActor.get());
curActor->m_header.read(reader);
++curLevel;
printf("%d: %s\n", curLevel, curActor->m_header.m_name.data());
}
else if (header.getMagic() == ActorMatrixChunk::MAGIC)
{
assert(curActor.get());
curActor->m_matrix.read(reader);
}
else if (header.getMagic() == ActorPushChunk::MAGIC)
{
assert(curActor.get());
// TODO: push
}
else if (header.getMagic() == ActorPopChunk::MAGIC)
{
assert(curActor.get());
// TODO: pop
--curLevel;
}
else if (header.getMagic() == ActorMaterialChunk::MAGIC)
{
assert(curActor.get());
curActor->m_materials.read(reader);
}
else if (header.getMagic() == ActorModelChunk::MAGIC)
{
assert(curActor.get());
curActor->m_models.read(reader);
}
else if (header.getMagic() == ActorEmptyChunk::MAGIC)
{
assert(curActor.get());
curActor->m_empty.read(reader);
}
else if (header.getMagic() == ActorBBoxChunk::MAGIC)
{
assert(curActor.get());
curActor->m_bbox.read(reader);
}
else if (header.isNULL())
{
if (!curActor.get() || !curActor->isValid())
throw Commons::SerializationException("Actor object is incorrect");
actors.push_back(curActor);
curActor.reset();
}
else
{
std::stringstream ss;
ss << "Unknown chunk: " << header.getMagic() << " at " << reader.tell();
throw Commons::SerializationException(ss.str());
}
uint32_t redSize = reader.tell() - lastOffset;
if (redSize != header.getSize())
{
std::stringstream ss;
ss << "Incorrect chunk size red: required: " << header.getSize() << " current " << redSize;
//throw SerializationException(ss.str()); // TODO: warning
//printf("%s\n", ss.str().data());
}
}
}
