int main(void)
{
auto renderWindow = CreateRenderWindow();
auto inputComponent = CreateInputHandler(renderWindow);
auto gameBoard = CreateGameBoard();
const auto numTiles = gameBoard->GetNumTiles();
auto renderComponent = CreateGameRenderer(*gameBoard, renderWindow);
auto boardController = std::make_unique<BoardController>(std::move(gameBoard));
auto playerController = CreatePlayerController(NUM_PLAYERS);
{
auto chooser = std::make_shared<TileChooser>(NUM_PLAYERS, 10, *renderComponent);
inputComponent->AddObserver(chooser);
chooser->ChooseTiles();
//chooser->AutoChooseTiles();
chooser->AssignTilesToPlayers(*playerController);
}
{
auto manager = std::make_shared<GameManager>(std::move(renderComponent), std::move(boardController), playerController);
inputComponent->AddObserver(manager);
playerController->ObserveTimers(manager);
manager->StartGame();
}
glfwDestroyWindow(renderWindow);
glfwTerminate();
}
//--------------------------------------------------------------------------
VeRenderWindowPtr VeRenderer::CreateRenderWindow(const char* pcTitle,
int32_t w, int32_t h, int32_t x, int32_t y, uint32_t u32Flags) noexcept
{
VeDesktopVideoPtr spVideo = VeDynamicCast(VeDesktopVideo, venus3d.GetVideo());
if (!spVideo) return nullptr;
VeDesktopWindowPtr spWindow = spVideo->Create(pcTitle, w, h, x, y, u32Flags);
VE_ASSERT(spWindow);
VeRenderWindowPtr spRes = CreateRenderWindow(spWindow);
spWindow = nullptr;
return spRes;
}
CMainRoot::CMainRoot()
{
#ifdef _DEBUG
if(LoadRenderSystemLibrary("Plugins\\RenderSystemDX9d.dll") == true)
#else
if(LoadRenderSystemLibrary("Plugins\\RenderSystemDX9.dll") == true)
#endif
{
// # InitLua
//InitLua(CUICombo::m_pLuaState);
// ----
// UI Theme
std::string strThemeFilename = "Data\\UI\\UIStyle.xml";
// ----
GetStyleMgr().Create(strThemeFilename.c_str());
// ----
// # UI Font
std::string strLanguage = IniGetStr("GameUI.cfg", "UIConfig", "language");
std::string strFont1 = IniGetStr("Font.cfg",strLanguage.c_str(), "font1");
// ----
UIGraph::getInstance().initFont(strFont1.c_str(),13);
// ----
// # Create UI
std::string strUIFilename = IniGetStr("GameUI.cfg", "UIConfig", "file");
// ----
CDlgMain::getInstance().create(strUIFilename.c_str(), "IDD_MAIN");
// ----
// # Load UI Language
setUILanguage(strLanguage);
// ----
// # (leo123) : i think next variables must be in register
// # Create Render System Window
int nWidth = IniGetInt("Game.cfg", "display", "width", 800);
int nHeight = IniGetInt("Game.cfg", "display", "height", 500);
// ----
CreateRenderWindow(GAME_TITLE_W, nWidth, nHeight);
// # Common Materials
//CRenderNodeMgr::getInstance().loadRenderNode("Data\\Common.mat.csv",NULL);
//CRenderNodeMgr::getInstance().loadRenderNode("EngineRes\\Common.mat.csv",NULL);
//DirectoryList("EngineRes\\shader",MATERIAL_GEOMETRY);
DirectoryList("EngineRes\\shader\\geometry",RF_GEOMETRY);
DirectoryList("EngineRes\\shader\\glow",RF_GLOW);
DirectoryList("EngineRes\\shader\\bump",RF_BUMP);
DirectoryList("EngineRes\\shader\\post-processing",RF_GEOMETRY);
DirectoryList("EngineRes\\shader\\ui",RF_GEOMETRY);
//DirectoryList("Data\\shader\\");
// ----
// # NetWork
NETWORK.SetHWND (m_hWnd);
NETWORK.SetWinMsgNum(WM_GM_JOIN_CLIENT_MSG_PROC);
NETWORK.SetProtocolCore(ProtocolCore);
}
}
int TAManager::OnTACommandHandle(unsigned long nEvent, unsigned long wParam, unsigned long lParam)//APP->TA
{
char* clParam = NULL;
clParam = (char*)lParam;
TAResult taResult = {0};
CreateMediaClient(DEMO_MEDIA_VIDEO);
CreateRenderWindow();
CreateMediaClient(DEMO_MEDIA_AUDIO);
switch (nEvent)
{
case WBXI_EVENTTYPE_TA_VIDEO_GETCAPTUREDEVICENUM:
{
ClearCameraList();
int nNum = 0;
TAResult *pResult = NULL;
if(m_pDemoClient->GetDeviceList(DEMO_MEDIA_VIDEO, DEV_TYPE_CAMERA, m_CameraList) == WME_S_OK)
{
nNum = m_CameraList.size();
pResult = new TAResult;
pResult->nStrLen = DEFAULT_BUFFER_LEN;
pResult->szTAStr = new char[pResult->nStrLen];
memset(pResult->szTAStr, 0, pResult->nStrLen);
for(int i=0; i<nNum; i++)
{
DeviceProperty Dev = m_CameraList.at(i);
if(i > 0)
{
sprintf_s(pResult->szTAStr, pResult->nStrLen, "%s#%s", pResult->szTAStr, Dev.dev_name);
}
else
{
sprintf_s(pResult->szTAStr, pResult->nStrLen, "%s", Dev.dev_name);
}
}
pResult->nStrLen = strlen(pResult->szTAStr);
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_VIDEO_GETCAPTUREDEVICENUM, nNum, pResult);
DeleteTaResult(1, pResult);
}
break;
case WBXI_EVENTTYPE_TA_VIDEO_SELECTCAPTUREDEVICE:
{
bool bResult = 0;
long ret = WME_E_FAIL;
char *p = (char *)lParam;
if(m_pDemoClient )
{
if(wParam < m_CameraList.size())
{
DeviceProperty Dev = m_CameraList.at(wParam);
if(*p == '0')
{
ret = m_pDemoClient->SetCamera(DEMO_PREVIEW_TRACK, Dev.dev);
}
else if(*p == '1')
{
ret = m_pDemoClient->SetCamera(DEMO_LOCAL_TRACK, Dev.dev);
}
// if(ret == WME_S_OK)
{
bResult = 1;
}
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_VIDEO_SELECTCAPTUREDEVICE, bResult, NULL);
}
break;
case WBXI_EVENTTYPE_TA_VIDEO_GETCURRENTCAPTUREDEVICE:
{
int nDevIndex = -1;
if(m_pDemoClient )
{
IWmeMediaDevice *pDev = NULL;
long ret = WME_E_FAIL;
char *p = (char *)lParam;
if(*p == '0')
{
ret = m_pDemoClient->GetCaptureDevice(DEMO_PREVIEW_TRACK, DEV_TYPE_CAMERA, &pDev);
}
else if(*p == '1')
{
ret = m_pDemoClient->GetCaptureDevice(DEMO_LOCAL_TRACK, DEV_TYPE_CAMERA, &pDev);
}
if(ret == WME_S_OK && pDev)
{
for(int i=0; i<m_CameraList.size(); i++)
{
DeviceProperty Dev = m_CameraList.at(i);
if(WME_S_OK == pDev->IsSameDevice(Dev.dev))
{
nDevIndex = i;
break;
}
}
pDev->Release();
pDev = NULL;
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_VIDEO_GETCURRENTCAPTUREDEVICE, nDevIndex, NULL);
}
break;
case WBXI_EVENTTYPE_TA_VIDEO_GETENCODINGPARAMLIST:
{
int nNum = 0;
TAResult *pResult = NULL;
m_VideoCapabilityList.clear();
if(m_pDemoClient->GetMediaCapabilities(DEMO_MEDIA_VIDEO, &m_VideoCapabilityList) == WME_S_OK)
{
nNum = m_VideoCapabilityList.size();
pResult = new TAResult;
pResult->nStrLen = DEFAULT_BUFFER_LEN;
pResult->szTAStr = new char[pResult->nStrLen];
memset(pResult->szTAStr, 0, pResult->nStrLen);
for(int i=0; i<nNum; i++)
{
WmeVideoMediaCapability vc = m_VideoCapabilityList.at(i);
if(i > 0)
{
sprintf_s(pResult->szTAStr, pResult->nStrLen, "%s#%s, %dx%d", pResult->szTAStr, m_mapVideoCodecName[vc.eCodecType].c_str(), vc.width, vc.height);
}
else
{
sprintf_s(pResult->szTAStr, pResult->nStrLen, "%s, %dx%d", m_mapVideoCodecName[vc.eCodecType].c_str(), vc.width, vc.height);
}
}
pResult->nStrLen = strlen(pResult->szTAStr);
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_VIDEO_GETENCODINGPARAMLIST, nNum, pResult);
DeleteTaResult(1, pResult);
}
break;
case WBXI_EVENTTYPE_TA_VIDEO_SELECTENCODINGPARAM:
{
bool bResult = 0;
long ret = WME_E_FAIL;
if(m_pDemoClient )
{
if(wParam < m_VideoCapabilityList.size())
{
WmeVideoMediaCapability vc = m_VideoCapabilityList.at(wParam);
ret = m_pDemoClient->SetMediaCodec(DEMO_MEDIA_VIDEO, DEMO_LOCAL_TRACK, vc.eCodecType);
ret = m_pDemoClient->SetMediaCapability(DEMO_MEDIA_VIDEO, DEMO_LOCAL_TRACK, &vc);
if(ret == WME_S_OK)
{
bResult = 1;
}
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_VIDEO_SELECTENCODINGPARAM, bResult, NULL);
}
break;
case WBXI_EVENTTYPE_TA_VIDEO_CHECK_ENCODINGPARAM:
{
int nIndex = -1;
long ret = WME_E_FAIL;
if(m_pDemoClient )
{
WmeVideoMediaCapability wmc;
ret = m_pDemoClient->GetCapability(DEMO_MEDIA_VIDEO, DEMO_LOCAL_TRACK, &wmc);
WmeCodecType codecType = WmeCodecType_Unknown;
ret = m_pDemoClient->GetMediaCodec(DEMO_MEDIA_VIDEO, DEMO_LOCAL_TRACK, codecType);
for(int i=0; i<m_VideoCapabilityList.size(); i++)
{
WmeVideoMediaCapability vc = m_VideoCapabilityList.at(i);
if(vc.eCodecType == codecType && vc.width == wmc.width
&& vc.height == wmc.height) //&& vc.frame_layer[vc.frame_layer_number-1] == wmc.frame_layer[wmc.frame_layer_number-1]
{
nIndex = i;
break;
}
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_VIDEO_CHECK_ENCODINGPARAM, nIndex, NULL);
}
break;
case WBXI_EVENTTYPE_TA_VIDEO_GETENCODELEVEL:
{
}
break;
case WBXI_EVENTTYPE_TA_VIDEO_STARTPREVIEW:
{
long ret = WME_E_FAIL;
bool bResult = 0;
if(m_pDemoClient)
{
ret = m_pDemoClient->SetRenderView(DEMO_PREVIEW_TRACK, m_previewerWindowHandle, false);
ret = m_pDemoClient->StartMediaTrack(DEMO_MEDIA_VIDEO, DEMO_PREVIEW_TRACK);
}
if(ret == WME_S_OK)
bResult = 1;
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_VIDEO_STARTPREVIEW, bResult, NULL);
}
break;
case WBXI_EVENTTYPE_TA_VIDEO_STOPPREVIEW:
{
long ret = WME_E_FAIL;
bool bResult = 0;
if(m_pDemoClient)
{
ret = m_pDemoClient->StopRenderView(DEMO_PREVIEW_TRACK);
ret = m_pDemoClient->StopMediaTrack(DEMO_MEDIA_VIDEO, DEMO_PREVIEW_TRACK);
}
if(ret == WME_S_OK)
bResult = 1;
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_VIDEO_STOPPREVIEW, bResult, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_GETCAPTUREDEVICENUM:
{
ClearMicList();
int nNum = 0;
TAResult *pResult = NULL;
if(m_pDemoClient->GetDeviceList(DEMO_MEDIA_AUDIO, DEV_TYPE_MIC, m_MicList) == WME_S_OK)
{
nNum = m_MicList.size();
pResult = new TAResult;
pResult->nStrLen = DEFAULT_BUFFER_LEN;
pResult->szTAStr = new char[pResult->nStrLen];
memset(pResult->szTAStr, 0, pResult->nStrLen);
for(int i=0; i<nNum; i++)
{
DeviceProperty Dev = m_MicList.at(i);
if(i > 0)
{
sprintf_s(pResult->szTAStr, pResult->nStrLen, "%s#%s", pResult->szTAStr, Dev.dev_name);
}
else
{
sprintf_s(pResult->szTAStr, pResult->nStrLen, "%s", Dev.dev_name);
}
}
pResult->nStrLen = strlen(pResult->szTAStr);
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_GETCAPTUREDEVICENUM, nNum, pResult);
DeleteTaResult(1, pResult);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_SELECTCAPTUREDEVICE:
{
bool bResult = 0;
long ret = WME_E_FAIL;
if(m_pDemoClient )
{
if(wParam < m_MicList.size())
{
DeviceProperty Dev = m_MicList.at(wParam);
ret = m_pDemoClient->SetMic(Dev.dev);
if(ret == WME_S_OK)
{
bResult = 1;
}
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_SELECTCAPTUREDEVICE, bResult, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_GETCURRENTCAPTUREDEVICE:
{
int nDevIndex = -1;
if(m_pDemoClient )
{
IWmeMediaDevice *pDev = NULL;
long ret = WME_E_FAIL;
ret = m_pDemoClient->GetCaptureDevice(DEMO_LOCAL_TRACK, DEV_TYPE_MIC, &pDev);
if(ret == WME_S_OK && pDev)
{
for(int i=0; i<m_MicList.size(); i++)
{
DeviceProperty Dev = m_MicList.at(i);
if(WME_S_OK == pDev->IsSameDevice(Dev.dev))
{
nDevIndex = i;
break;
}
}
pDev->Release();
pDev = NULL;
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_GETCURRENTCAPTUREDEVICE, nDevIndex, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_GETPLAYDEVICENUM:
{
ClearSpeakerList();
int nNum = 0;
TAResult *pResult = NULL;
if(m_pDemoClient->GetDeviceList(DEMO_MEDIA_AUDIO, DEV_TYPE_SPEAKER, m_SpeakerList) == WME_S_OK)
{
nNum = m_SpeakerList.size();
pResult = new TAResult;
pResult->nStrLen = DEFAULT_BUFFER_LEN;
pResult->szTAStr = new char[pResult->nStrLen];
memset(pResult->szTAStr, 0, pResult->nStrLen);
for(int i=0; i<nNum; i++)
{
DeviceProperty Dev = m_SpeakerList.at(i);
if(i > 0)
{
sprintf_s(pResult->szTAStr, pResult->nStrLen, "%s#%s", pResult->szTAStr, Dev.dev_name);
}
else
{
sprintf_s(pResult->szTAStr, pResult->nStrLen, "%s", Dev.dev_name);
}
}
pResult->nStrLen = strlen(pResult->szTAStr);
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_GETPLAYDEVICENUM, nNum, pResult);
DeleteTaResult(1, pResult);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_SELECTPLAYDEVICE:
{
bool bResult = 0;
long ret = WME_E_FAIL;
if(m_pDemoClient )
{
if(wParam < m_SpeakerList.size())
{
DeviceProperty Dev = m_SpeakerList.at(wParam);
ret = m_pDemoClient->SetSpeaker(Dev.dev);
if(ret == WME_S_OK)
{
bResult = 1;
}
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_SELECTPLAYDEVICE, bResult, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_GETCURRENTPLAYDEVICE:
{
int nDevIndex = -1;
if(m_pDemoClient )
{
IWmeMediaDevice *pDev = NULL;
long ret = WME_E_FAIL;
ret = m_pDemoClient->GetCaptureDevice(DEMO_PREVIEW_TRACK, DEV_TYPE_SPEAKER, &pDev);
if(ret == WME_S_OK && pDev)
{
for(int i=0; i<m_SpeakerList.size(); i++)
{
DeviceProperty Dev = m_SpeakerList.at(i);
if(WME_S_OK == pDev->IsSameDevice(Dev.dev))
{
nDevIndex = i;
break;
}
}
pDev->Release();
pDev = NULL;
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_GETCURRENTPLAYDEVICE, nDevIndex, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_GETENCODINGPARAMLIST:
{
int nNum = 0;
TAResult *pResult = NULL;
m_AudioCapabilityList.clear();
if(m_pDemoClient->GetMediaCapabilities(DEMO_MEDIA_AUDIO, &m_AudioCapabilityList) == WME_S_OK)
{
nNum = m_AudioCapabilityList.size();
pResult = new TAResult;
pResult->nStrLen = DEFAULT_BUFFER_LEN;
pResult->szTAStr = new char[pResult->nStrLen];
memset(pResult->szTAStr, 0, pResult->nStrLen);
for(int i=0; i<nNum; i++)
{
WmeAudioMediaCapability ac = m_AudioCapabilityList.at(i);
if(i > 0)
{
sprintf_s(pResult->szTAStr, pResult->nStrLen, "%s#%s", pResult->szTAStr, m_mapAudioCodecName[ac.eCodecType].c_str());
}
else
{
sprintf_s(pResult->szTAStr, pResult->nStrLen, "%s", m_mapAudioCodecName[ac.eCodecType].c_str());
}
}
pResult->nStrLen = strlen(pResult->szTAStr);
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_GETENCODINGPARAMLIST, nNum, pResult);
DeleteTaResult(1, pResult);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_SELECTENCODINGPARAM:
{
bool bResult = 0;
long ret = WME_E_FAIL;
if(m_pDemoClient )
{
if(wParam < m_AudioCapabilityList.size())
{
WmeAudioMediaCapability mc = m_AudioCapabilityList.at(wParam);
ret = m_pDemoClient->SetMediaCodec(DEMO_MEDIA_AUDIO, DEMO_LOCAL_TRACK, mc.eCodecType);
if(ret == WME_S_OK)
{
bResult = 1;
}
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_SELECTENCODINGPARAM, bResult, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_CHECK_ENCODINGPARAM:
{
int nIndex = -1;
long ret = WME_E_FAIL;
if(m_pDemoClient )
{
WmeCodecType codecType = WmeCodecType_Unknown;
ret = m_pDemoClient->GetMediaCodec(DEMO_MEDIA_AUDIO, DEMO_LOCAL_TRACK, codecType);
for(int i=0; i<m_AudioCapabilityList.size(); i++)
{
WmeAudioMediaCapability mc = m_AudioCapabilityList.at(i);
if(mc.eCodecType == codecType)
{
nIndex = i;
break;
}
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_CHECK_ENCODINGPARAM, nIndex, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_CAPTUREMUTE:
{
bool bRet = 0;
if(m_pDemoClient)
{
m_pDemoClient->MuteAudio(DEV_TYPE_MIC, true);
bRet = 1;
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_CAPTUREMUTE, bRet, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_CAPTUREUNMUTE:
{
bool bRet = 0;
if(m_pDemoClient)
{
m_pDemoClient->MuteAudio(DEV_TYPE_MIC, false);
bRet = 1;
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_CAPTUREUNMUTE, bRet, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_CHECK_CAPTUREMUTE:
{
bool bResult = 0;
if(m_pDemoClient)
{
bResult = m_pDemoClient->IsAudioMute(DEV_TYPE_MIC);
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_CHECK_CAPTUREMUTE, bResult, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_SETCAPTUREVOLUME:
{
int nVol = wParam;
bool bResult = 0;
if(nVol >= 0 && nVol <= 65535)
{
if(m_pDemoClient)
{
m_pDemoClient->SetAudioVolume(DEV_TYPE_MIC, nVol);
bResult = 1;
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_SETCAPTUREVOLUME, bResult, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_GETCAPTUREVOLUME:
{
int nVol = -1;
long ret = WME_E_FAIL;
if(m_pDemoClient)
{
ret = m_pDemoClient->GetAudioVolume(DEV_TYPE_MIC, nVol);
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_GETCAPTUREVOLUME, nVol, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_PLAYMUTE:
{
bool bRet = 0;
if(m_pDemoClient)
{
m_pDemoClient->MuteAudio(DEV_TYPE_SPEAKER, true);
bRet = 1;
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_PLAYMUTE, bRet, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_PLAYUNMUTE:
{
bool bRet = 0;
if(m_pDemoClient)
{
m_pDemoClient->MuteAudio(DEV_TYPE_SPEAKER, false);
bRet = 1;
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_PLAYUNMUTE, bRet, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_CHECK_PLAYMUTE:
{
bool bResult = 0;
if(m_pDemoClient)
{
bResult = m_pDemoClient->IsAudioMute(DEV_TYPE_SPEAKER);
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_CHECK_PLAYMUTE, bResult, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_SETPLAYVOLUME:
{
int nVol = wParam;
bool bResult = 0;
if(nVol >= 0 && nVol <= 65535)
{
if(m_pDemoClient)
{
m_pDemoClient->SetAudioVolume(DEV_TYPE_SPEAKER, nVol);
bResult = 1;
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_SETPLAYVOLUME, bResult, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_GETPLAYVOLUME:
{
int nVol = -1;
long ret = WME_E_FAIL;
if(m_pDemoClient)
{
ret = m_pDemoClient->GetAudioVolume(DEV_TYPE_SPEAKER, nVol);
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_AUDIO_GETPLAYVOLUME, nVol, NULL);
}
break;
case WBXI_EVENTTYPE_TA_AUDIO_GETVOICELEVEL:
{
}
break;
case WBXI_EVENTTYPE_TA_ROLE_ASHOST:
{
m_bHost = TRUE;
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_ROLE_ASHOST, 1, NULL);
}
break;
case WBXI_EVENTTYPE_TA_ROLE_ASCLIENT:
{
m_bHost = FALSE;
char *pIP = (char *)lParam;
if(pIP)
{
strcpy_s(m_strHostIP, sizeof(m_strHostIP), pIP);
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_ROLE_ASCLIENT, 1, NULL);
}
break;
case WBXI_EVENTTYPE_TA_ROLE_SETHOSTIP:
{
char *pIP = (char *)lParam;
strcpy_s(m_strHostIP, sizeof(m_strHostIP), pIP);
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_ROLE_SETHOSTIP, 1, NULL);
}
break;
case WBXI_EVENTTYPE_TA_ACTION_CONNECT:
{
long ret = WME_E_FAIL;
if (m_pDemoClient)
{
m_pDemoClient->SetRenderView(DEMO_LOCAL_TRACK, m_senderWindowHandle, false);
m_pDemoClient->SetRenderView(DEMO_REMOTE_TRACK, m_receiverWindowHandle, false);
ret = m_pDemoClient->StartMediaTrack(DEMO_MEDIA_VIDEO, DEMO_LOCAL_TRACK);
ret = m_pDemoClient->StartMediaTrack(DEMO_MEDIA_VIDEO, DEMO_REMOTE_TRACK);
ret = m_pDemoClient->StartMediaTrack(DEMO_MEDIA_AUDIO, DEMO_LOCAL_TRACK);
ret = m_pDemoClient->StartMediaTrack(DEMO_MEDIA_AUDIO, DEMO_REMOTE_TRACK);
if (m_bHost)
{
ret = m_pDemoClient->InitHost(DEMO_MEDIA_VIDEO);
ret = m_pDemoClient->InitHost(DEMO_MEDIA_AUDIO);
}
else
{
ret = m_pDemoClient->ConnectRemote(DEMO_MEDIA_VIDEO, m_strHostIP);
ret = m_pDemoClient->ConnectRemote(DEMO_MEDIA_AUDIO, m_strHostIP);
}
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_ACTION_CONNECT, 1, NULL);
}
break;
case WBXI_EVENTTYPE_TA_ACTION_DISCONNECT:
{
long ret = WME_E_FAIL;
if (m_pDemoClient)
{
m_pDemoClient->StopRenderView(DEMO_LOCAL_TRACK);
m_pDemoClient->StopRenderView(DEMO_REMOTE_TRACK);
ret = m_pDemoClient->StopMediaTrack(DEMO_MEDIA_VIDEO, DEMO_LOCAL_TRACK);
ret = m_pDemoClient->StopMediaTrack(DEMO_MEDIA_VIDEO, DEMO_REMOTE_TRACK);
ret = m_pDemoClient->StopMediaTrack(DEMO_MEDIA_AUDIO, DEMO_LOCAL_TRACK);
ret = m_pDemoClient->StopMediaTrack(DEMO_MEDIA_AUDIO, DEMO_REMOTE_TRACK);
m_pDemoClient->DisConnect(DEMO_MEDIA_VIDEO);
m_pDemoClient->DisConnect(DEMO_MEDIA_AUDIO);
DeleteMediaClient(DEMO_MEDIA_VIDEO);
DeleteMediaClient(DEMO_MEDIA_AUDIO);
}
WBXI_TANetworkHandleCommand(hComponent, WBXI_TA_RESULT_ACTION_DISCONNECT, 1, NULL);
}
break;
}
return 0;
}
