示例#1
0
uint32 CTransitionAggregate::EngineMessageFn( LPBASECLASS pObject, uint32 messageID, void *pData, LTFLOAT fData )
{
	switch( messageID )
	{
		case MID_OBJECTCREATED :
		{
			if( fData != OBJECTCREATED_SAVEGAME )
			{
				ObjectCreated( pObject );
			}
		}
		break;

		case MID_SAVEOBJECT :
		{
			Save( (ILTMessage_Write*)pData, (uint32)fData );
		}
		break;

		case MID_LOADOBJECT :
		{
			Load( (ILTMessage_Read*)pData, (uint32)fData );
		}
		break;
	}

	return IAggregate::EngineMessageFn( pObject, messageID, pData, fData );
}
示例#2
0
std::shared_ptr<MediaObjectImpl>
MediaSet::ref (MediaObjectImpl *mediaObjectPtr)
{
  std::unique_lock <std::recursive_mutex> lock (recMutex);
  std::shared_ptr<MediaObjectImpl> mediaObject;

  if (mediaObjectPtr == NULL) {
    throw KurentoException (MEDIA_OBJECT_NOT_FOUND, "Invalid object");
  }

  mediaObject =  std::shared_ptr<MediaObjectImpl> (mediaObjectPtr, [this] (
  MediaObjectImpl * obj) {
    // this will always exist because destructor is waiting for its threads
    this->releasePointer (obj);
  });

  objectsMap[mediaObject->getId()] = std::weak_ptr<MediaObjectImpl> (mediaObject);

  if (mediaObject->getParent() ) {
    std::shared_ptr<MediaObjectImpl> parent = std::dynamic_pointer_cast
        <MediaObjectImpl> (mediaObject->getParent() );

    childrenMap[parent->getId()][mediaObject->getId()] = mediaObject;
  }

  auto parent = mediaObject->getParent();

  if (parent) {
    for (auto session : reverseSessionMap[parent->getId()]) {
      ref (session, mediaObject);
    }
  }

  mediaObject->postConstructor ();

  if (this->serverManager) {
    lock.unlock ();
    serverManager->signalObjectCreated (ObjectCreated (this->serverManager,
                                        std::dynamic_pointer_cast<MediaObject> (mediaObject) ) );
  }

  return mediaObject;
}
示例#3
0
uint32 GameBase::EngineMessageFn(uint32 messageID, void *pData, float fData)
{
	switch(messageID)
	{
        case MID_ACTIVATING:
		{
			g_pCommonLT->SetObjectFlags(m_hObject, OFT_User, USRFLG_GAMEBASE_ACTIVE, USRFLG_GAMEBASE_ACTIVE);
		}
		break;

		case MID_DEACTIVATING:
		{
			g_pCommonLT->SetObjectFlags(m_hObject, OFT_User, 0, USRFLG_GAMEBASE_ACTIVE);
		}
		break;

        case MID_PRECREATE:
		{
            uint32 dwRet = BaseClass::EngineMessageFn(messageID, pData, fData);

			int nInfo = (int)fData;
			if (nInfo == PRECREATE_WORLDFILE || nInfo == PRECREATE_STRINGPROP || nInfo == PRECREATE_NORMAL)
			{
				ObjectCreateStruct* pocs = (ObjectCreateStruct*)pData;
				if( !ReadProp( pocs ))
					return 0;
			}

			return dwRet;
		}
		break;

		case MID_OBJECTCREATED:
		{
			if( fData != OBJECTCREATED_SAVEGAME )
			{
				ObjectCreated( reinterpret_cast<const GenericPropList*>(pData) );
			}
		}
		break;

		case MID_MODELSTRINGKEY:
		{
			HandleModelString( (ArgList*)pData );
		}
		break;


		case MID_SAVEOBJECT:
		{
			Save((ILTMessage_Write*)pData);
		}
		break;

		case MID_LOADOBJECT:
		{
			Load((ILTMessage_Read*)pData);
		}
		break;

		default:
		break;
	}

	return BaseClass::EngineMessageFn(messageID, pData, fData);
}