MainWindow::MainWindow(const nglContextInfo& rContextInfo, const nglWindowInfo& rInfo, bool ShowFPS, const nglContext* pShared )
: nuiMainWindow(rContextInfo, rInfo, pShared, nglPath(ePathCurrent)), nuiNotificationObserver(), mEventSink(this)
{
mpThread1 = NULL;
mpThread2 = NULL;
RegisterObserver(NOTIF_PING, this);
RegisterObserver(NOTIF_PONG, this);
}
status_t BnRTCNode::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case kIDTransport: {
rtc_binder_data_t out;
out.data = &data;
out.reply = reply;
// Reserved 4 bytes;
reply->writeInt32(0);
int ret = Transport(&out);
int pos = reply->dataPosition();
reply->setDataPosition(0);
reply->writeInt32(ret);
reply->setDataPosition(pos);
return NO_ERROR;
} break;
case kIDResigerObs: {
CHECK_INTERFACE(IRTCNode, data, reply);
sp<IBinder> handle = data.readStrongBinder();
sp<IRTCNode> node = interface_cast<IRTCNode>(handle);
int ret = RegisterObserver(node);
reply->writeInt32(ret);
return NO_ERROR;
}break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
void Transport::InitTCPStack(const Peer &_peer)
{
assert(s_IsPlatformInit);
m_tcpMode = true;
// create stream
TCPStream *tcpstream = new TCPStream(_peer);
if(_peer.GetPort() != 0)
{
tcpstream->CreateAndBind();
}
else
{
tcpstream->Init();
}
//
m_streams.push_back(tcpstream);
// create listener - note: we do not need reliable listener on tcp
UnreliableListener *unreliablelistener = new UnreliableListener();
m_listeners.push_back(unreliablelistener);
// attach
tcpstream->AttachListener(*unreliablelistener);
RegisterObserver(m_observer);
}
CTransDataSubject::CTransDataSubject()
{
m_recvPos = 0;
m_fillPos = 0;
for (int i = 0; i<MAX_OBERSERVER_NUM; i++)
m_pOberverBuff[i] = NULL;
m_curOberserverNum = 0;
//逐个注册观察者
m_pOberserverHandler = new CCurrentStatue();
RegisterObserver(m_pOberserverHandler);
m_pOberserverHandler = new CAutoCtrl();
RegisterObserver(m_pOberserverHandler);
m_pOberserverHandler = new CWaterCtrl();
RegisterObserver(m_pOberserverHandler);
m_pOberserverHandler = new CHotCtrl();
RegisterObserver(m_pOberserverHandler);
m_pOberserverHandler = new CLightCtrl();
RegisterObserver(m_pOberserverHandler);
m_pOberserverHandler = new CModeCtrl();
RegisterObserver(m_pOberserverHandler);
m_pOberserverHandler = new CWindCtrl();
RegisterObserver(m_pOberserverHandler);
}
uint8_t QICMotionCapture::CreateMotionStream(StreamsManager *pSM, string streamName) {
// 1. create video stream for application
// video stream is created here but deleting in BaseV4L2VideoCapture because video stream is relevant to hardware device
QICMotionStream *pStream = new QICMotionStream(pSM, streamName);
// 2. register video stream as carrier for receiving data
RegisterCarrier((IDeviceCarrier *)pStream);
// 3. register video stream as observer for obtaining notification
RegisterObserver((IDeviceObserver *)pStream);
return 1;
}
// Called when the game starts
void UBrainObservable::BeginPlay()
{
Super::BeginPlay();
FScriptDelegate Delegate, Delegate2;
Delegate.BindUFunction(this, "OnActorCollisionBegin");
Delegate2.BindUFunction(this, "OnActorCollisionEnd");
GetOwner()->OnActorBeginOverlap.Add(Delegate);
GetOwner()->OnActorEndOverlap.Add(Delegate2);
for (int32 i = 0; i < _list.Num(); i++){
AActor* actor = _list[i];
UBrainObserver* ub = actor->FindComponentByClass<UBrainObserver>();
if (ub != nullptr)
RegisterObserver(ub);
}
}
void Transport::InitUDPStack(const Peer &_peer)
{
assert(s_IsPlatformInit);
m_tcpMode = false;
// create stream
UDPStream *udpstream = new UDPStream(_peer);
udpstream->CreateAndBind();
m_streams.push_back(udpstream);
// create listener
UnreliableListener *unreliablelistener = new UnreliableListener();
m_listeners.push_back(unreliablelistener);
ReliableListener *reliablelistener = new ReliableListener();
m_listeners.push_back(reliablelistener);
// attach
udpstream->AttachListener(*unreliablelistener);
udpstream->AttachListener(*reliablelistener);
RegisterObserver(m_observer);
}
bool UMyBlackboardComponent::PushBlackboard(UBlackboardData* NewAsset, TArray<struct FBlackboardKeySelector> &Params)
{
UAISystem* AISystem = UAISystem::GetCurrentSafe(GetWorld());
if (AISystem == nullptr)
{
return false;
}
//makes a copy of the blackboard
//otherwise the data in the bb can be owerwritten by other calls or other instances
UBlackboardData* NewAssetCopy = CopyBlackboardData(NewAsset);
//save current bb on stack
BBStack.Add(BlackboardAsset);
UBlackboardData* OldAsset = BlackboardAsset;
//and replace it by new bb
BlackboardAsset = NewAssetCopy;
bool bSuccess = true;
const int32 NumKeys = NewAssetCopy->Keys.Num();
//make old bb parent of new bb
NewAssetCopy->Parent = OldAsset;
//update first key id accordingly
NewAssetCopy->UpdateKeyIDs();
TArray<FBlackboardInitializationData> InitList;
InitList.Reserve(NumKeys);
//grow ValueOffsets to contain new bb offsets
ValueOffsets.AddZeroed(NumKeys);
for (int32 KeyIndex = 0; KeyIndex < NumKeys; KeyIndex++)
{
if (NewAssetCopy->Keys[KeyIndex].KeyType)
{
InitList.Add(FBlackboardInitializationData(KeyIndex + NewAssetCopy->GetFirstKeyID(), NewAssetCopy->Keys[KeyIndex].KeyType->GetValueSize()));
}
}
// sort key values by memory size, so they can be packed better
// it still won't protect against structures, that are internally misaligned (-> uint8, uint32)
// but since all Engine level keys are good...
InitList.Sort(FBlackboardInitializationData::FMemorySort());
uint16 MemoryOffset = 0;
for (int32 Index = 0; Index < InitList.Num(); Index++)
{
ValueOffsets[InitList[Index].KeyID] = MemoryOffset + ValueMemory.Num();
MemoryOffset += InitList[Index].DataSize;
}
//grow ValueMemory to contain new bb data
//(also allows memory for parameters, this is not really neaded, to improve...)
ValueMemory.AddZeroed(MemoryOffset);
// initialize memory
for (int32 Index = 0; Index < InitList.Num(); Index++)
{
const FBlackboardEntry* KeyData = BlackboardAsset->GetKey(InitList[Index].KeyID);
uint8* RawData = GetKeyRawData(InitList[Index].KeyID);
KeyData->KeyType->Initialize(RawData);
}
int32 ParamIndex = 0;
for (int32 KeyIndex = 0; KeyIndex < NumKeys && ParamIndex<Params.Num(); KeyIndex++)
{
//for each parameter
if (NewAssetCopy->Keys[KeyIndex].KeyType&&NewAssetCopy->Keys[KeyIndex].EntryName.ToString().StartsWith("PARAM_"))
{
FBlackboard::FKey ParentKeyID = OldAsset->GetKeyID(Params[ParamIndex].SelectedKeyName);
FBlackboard::FKey ChildKeyID = BlackboardAsset->GetKeyID(BlackboardAsset->Keys[KeyIndex].EntryName);
if (ParentKeyID != FBlackboard::InvalidKey && ChildKeyID != FBlackboard::InvalidKey)
{
//redirect ValueOffset to the memory location of the actual argument
ValueOffsets[ChildKeyID] = ValueOffsets[ParentKeyID];
//add observer to propagate notifications to actual argument observers
DelegateHandles.Add(FMyKeyDelegate(ChildKeyID, RegisterObserver(ChildKeyID, this, FOnBlackboardChange::CreateLambda([this, ParentKeyID](const UBlackboardComponent& BComp, FBlackboard::FKey ChangedKeyID){
this->CallNotifyObservers(ParentKeyID);
}))));
ParamIndex++;
}
}
}
//saves number of parameters found
ParamsNumStack.Add(ParamIndex);
return bSuccess;
}
