ovr_sdk

annotate LibOVR/Src/Service/Service_NetClient.cpp @ 3:f12a8f74fe1f

find changesets by author, revision, files, or words in the commit message
added the Xcode project
author John Tsiombikas <nuclear@member.fsf.org>
date Wed, 21 Jan 2015 11:37:50 +0200
parents
children
rev   line source
nuclear@0 1 /************************************************************************************
nuclear@0 2
nuclear@0 3 Filename : Service_NetClient.cpp
nuclear@0 4 Content : Client for service interface
nuclear@0 5 Created : June 12, 2014
nuclear@0 6 Authors : Michael Antonov, Kevin Jenkins, Chris Taylor
nuclear@0 7
nuclear@0 8 Copyright : Copyright 2014 Oculus VR, LLC All Rights reserved.
nuclear@0 9
nuclear@0 10 Licensed under the Oculus VR Rift SDK License Version 3.2 (the "License");
nuclear@0 11 you may not use the Oculus VR Rift SDK except in compliance with the License,
nuclear@0 12 which is provided at the time of installation or download, or which
nuclear@0 13 otherwise accompanies this software in either electronic or hard copy form.
nuclear@0 14
nuclear@0 15 You may obtain a copy of the License at
nuclear@0 16
nuclear@0 17 http://www.oculusvr.com/licenses/LICENSE-3.2
nuclear@0 18
nuclear@0 19 Unless required by applicable law or agreed to in writing, the Oculus VR SDK
nuclear@0 20 distributed under the License is distributed on an "AS IS" BASIS,
nuclear@0 21 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
nuclear@0 22 See the License for the specific language governing permissions and
nuclear@0 23 limitations under the License.
nuclear@0 24
nuclear@0 25 ************************************************************************************/
nuclear@0 26
nuclear@0 27 #include "Service_NetClient.h"
nuclear@0 28 #include "../Net/OVR_MessageIDTypes.h"
nuclear@0 29
nuclear@0 30 #if defined (OVR_OS_MAC) || defined(OVR_OS_LINUX)
nuclear@0 31 #define GetCurrentProcessId getpid
nuclear@0 32 #endif
nuclear@0 33 OVR_DEFINE_SINGLETON(OVR::Service::NetClient);
nuclear@0 34
nuclear@0 35 namespace OVR { namespace Service {
nuclear@0 36
nuclear@0 37 using namespace OVR::Net;
nuclear@0 38
nuclear@0 39
nuclear@0 40 //// NetClient
nuclear@0 41
nuclear@0 42 NetClient::NetClient() :
nuclear@0 43 LatencyTesterAvailable(false),
nuclear@0 44 HMDCount(0),
nuclear@0 45 EdgeTriggeredHMDCount(false)
nuclear@0 46 {
nuclear@0 47 GetSession()->AddSessionListener(this);
nuclear@0 48
nuclear@0 49 // Register RPC functions
nuclear@0 50 registerRPC();
nuclear@0 51
nuclear@0 52 Start();
nuclear@0 53
nuclear@0 54 // Must be at end of function
nuclear@0 55 PushDestroyCallbacks();
nuclear@0 56 }
nuclear@0 57
nuclear@0 58 NetClient::~NetClient()
nuclear@0 59 {
nuclear@0 60 }
nuclear@0 61
nuclear@0 62 void NetClient::OnSystemDestroy()
nuclear@0 63 {
nuclear@0 64 onSystemDestroy();
nuclear@0 65 }
nuclear@0 66
nuclear@0 67 void NetClient::OnThreadDestroy()
nuclear@0 68 {
nuclear@0 69 onThreadDestroy();
nuclear@0 70 }
nuclear@0 71
nuclear@0 72 int NetClient::Run()
nuclear@0 73 {
nuclear@0 74 SetThreadName("NetClient");
nuclear@0 75
nuclear@0 76 while (!Terminated)
nuclear@0 77 {
nuclear@0 78 // Note: There is no watchdog here because the watchdog is part of the private code
nuclear@0 79
nuclear@0 80 GetSession()->Poll(false);
nuclear@0 81
nuclear@0 82 if (GetSession()->GetActiveSocketsCount() == 0)
nuclear@0 83 {
nuclear@0 84 Thread::MSleep(10);
nuclear@0 85 }
nuclear@0 86 }
nuclear@0 87
nuclear@0 88 return 0;
nuclear@0 89 }
nuclear@0 90
nuclear@0 91 void NetClient::OnReceive(ReceivePayload* pPayload, ListenerReceiveResult* lrrOut)
nuclear@0 92 {
nuclear@0 93 OVR_UNUSED(lrrOut);
nuclear@0 94 OVR_UNUSED(pPayload);
nuclear@0 95 }
nuclear@0 96
nuclear@0 97 void NetClient::OnDisconnected(Connection* conn)
nuclear@0 98 {
nuclear@0 99 OVR_UNUSED(conn);
nuclear@0 100
nuclear@0 101 OVR_DEBUG_LOG(("[NetClient] Disconnected"));
nuclear@0 102
nuclear@0 103 EdgeTriggeredHMDCount = false;
nuclear@0 104 }
nuclear@0 105
nuclear@0 106 void NetClient::OnConnected(Connection* conn)
nuclear@0 107 {
nuclear@0 108 OVR_UNUSED(conn);
nuclear@0 109
nuclear@0 110 OVR_DEBUG_LOG(("[NetClient] Connected to a server running version %d.%d.%d (my version=%d.%d.%d)",
nuclear@0 111 conn->RemoteMajorVersion, conn->RemoteMinorVersion, conn->RemotePatchVersion,
nuclear@0 112 RPCVersion_Major, RPCVersion_Minor, RPCVersion_Patch));
nuclear@0 113
nuclear@0 114 EdgeTriggeredHMDCount = false;
nuclear@0 115 }
nuclear@0 116
nuclear@0 117 bool NetClient::Connect(bool blocking)
nuclear@0 118 {
nuclear@0 119 // Set up bind parameters
nuclear@0 120 OVR::Net::BerkleyBindParameters bbp;
nuclear@0 121 bbp.Address = "::1"; // Bind to localhost only!
nuclear@0 122 bbp.blockingTimeout = 5000;
nuclear@0 123 OVR::Net::SockAddr sa;
nuclear@0 124 sa.Set("::1", VRServicePort, SOCK_STREAM);
nuclear@0 125
nuclear@0 126 // Attempt to connect
nuclear@0 127 OVR::Net::SessionResult result = GetSession()->ConnectPTCP(&bbp, &sa, blocking);
nuclear@0 128
nuclear@0 129 // Already connected counts as success too
nuclear@0 130 return result == Net::SessionResult_OK ||
nuclear@0 131 result == Net::SessionResult_AlreadyConnected ||
nuclear@0 132 result == Net::SessionResult_ConnectInProgress;
nuclear@0 133 }
nuclear@0 134
nuclear@0 135 void NetClient::Disconnect()
nuclear@0 136 {
nuclear@0 137 GetSession()->Shutdown();
nuclear@0 138 }
nuclear@0 139
nuclear@0 140 bool NetClient::IsConnected(bool attemptReconnect, bool blockOnReconnect)
nuclear@0 141 {
nuclear@0 142 // If it was able to connect,
nuclear@0 143 if (GetSession()->GetConnectionCount() > 0)
nuclear@0 144 {
nuclear@0 145 return true;
nuclear@0 146 }
nuclear@0 147 else if (attemptReconnect)
nuclear@0 148 {
nuclear@0 149 // Attempt to connect here
nuclear@0 150 Connect(blockOnReconnect);
nuclear@0 151
nuclear@0 152 // If it connected,
nuclear@0 153 if (GetSession()->GetConnectionCount() > 0)
nuclear@0 154 {
nuclear@0 155 return true;
nuclear@0 156 }
nuclear@0 157 }
nuclear@0 158
nuclear@0 159 // No connections
nuclear@0 160 return false;
nuclear@0 161 }
nuclear@0 162
nuclear@0 163 void NetClient::GetLocalProtocolVersion(int& major, int& minor, int& patch)
nuclear@0 164 {
nuclear@0 165 major = RPCVersion_Major;
nuclear@0 166 minor = RPCVersion_Minor;
nuclear@0 167 patch = RPCVersion_Patch;
nuclear@0 168 }
nuclear@0 169
nuclear@0 170 bool NetClient::GetRemoteProtocolVersion(int& major, int& minor, int& patch)
nuclear@0 171 {
nuclear@0 172 Ptr<Connection> conn = GetSession()->GetConnectionAtIndex(0);
nuclear@0 173
nuclear@0 174 if (conn)
nuclear@0 175 {
nuclear@0 176 major = conn->RemoteMajorVersion;
nuclear@0 177 minor = conn->RemoteMinorVersion;
nuclear@0 178 patch = conn->RemotePatchVersion;
nuclear@0 179 return true;
nuclear@0 180 }
nuclear@0 181
nuclear@0 182 return false;
nuclear@0 183 }
nuclear@0 184
nuclear@0 185
nuclear@0 186 //// NetClient API
nuclear@0 187
nuclear@0 188 const char* NetClient::GetStringValue(VirtualHmdId hmd, const char* key, const char* default_val)
nuclear@0 189 {
nuclear@0 190 if (!IsConnected(true, true))
nuclear@0 191 {
nuclear@0 192 return "";
nuclear@0 193 }
nuclear@0 194
nuclear@0 195 // If a null value is provided,
nuclear@0 196 if (!default_val)
nuclear@0 197 {
nuclear@0 198 default_val = "";
nuclear@0 199 }
nuclear@0 200
nuclear@0 201 ProfileGetValue1_Str = default_val;
nuclear@0 202
nuclear@0 203 OVR::Net::BitStream bsOut, returnData;
nuclear@0 204 bsOut.Write(hmd);
nuclear@0 205 bsOut.Write(key);
nuclear@0 206 bsOut.Write(default_val);
nuclear@0 207 if (!GetRPC1()->CallBlocking("GetStringValue_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 208 {
nuclear@0 209 return "";
nuclear@0 210 }
nuclear@0 211 if (!returnData.Read(ProfileGetValue1_Str))
nuclear@0 212 {
nuclear@0 213 OVR_ASSERT(false);
nuclear@0 214 }
nuclear@0 215 return ProfileGetValue1_Str.ToCStr();
nuclear@0 216 }
nuclear@0 217 bool NetClient::GetBoolValue(VirtualHmdId hmd, const char* key, bool default_val)
nuclear@0 218 {
nuclear@0 219 if (!IsConnected(true, true))
nuclear@0 220 {
nuclear@0 221 return default_val;
nuclear@0 222 }
nuclear@0 223
nuclear@0 224 OVR::Net::BitStream bsOut, returnData;
nuclear@0 225 bsOut.Write(hmd);
nuclear@0 226 bsOut.Write(key);
nuclear@0 227 bsOut.Write(default_val);
nuclear@0 228 if (!GetRPC1()->CallBlocking("GetBoolValue_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 229 {
nuclear@0 230 return default_val;
nuclear@0 231 }
nuclear@0 232 uint8_t out = 0;
nuclear@0 233 if (!returnData.Read(out))
nuclear@0 234 {
nuclear@0 235 OVR_ASSERT(false);
nuclear@0 236 }
nuclear@0 237 return out != 0;
nuclear@0 238 }
nuclear@0 239 int NetClient::GetIntValue(VirtualHmdId hmd, const char* key, int default_val)
nuclear@0 240 {
nuclear@0 241 if (!IsConnected(true, true))
nuclear@0 242 {
nuclear@0 243 return default_val;
nuclear@0 244 }
nuclear@0 245
nuclear@0 246 OVR::Net::BitStream bsOut, returnData;
nuclear@0 247 bsOut.Write(hmd);
nuclear@0 248 bsOut.Write(key);
nuclear@0 249 bsOut.Write(default_val);
nuclear@0 250 if (!GetRPC1()->CallBlocking("GetIntValue_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 251 {
nuclear@0 252 return default_val;
nuclear@0 253 }
nuclear@0 254 int32_t out = (int32_t)default_val;
nuclear@0 255 if (!returnData.Read(out))
nuclear@0 256 {
nuclear@0 257 OVR_ASSERT(false);
nuclear@0 258 }
nuclear@0 259 return out;
nuclear@0 260 }
nuclear@0 261 double NetClient::GetNumberValue(VirtualHmdId hmd, const char* key, double default_val)
nuclear@0 262 {
nuclear@0 263 if (!IsConnected(true, true))
nuclear@0 264 {
nuclear@0 265 return default_val;
nuclear@0 266 }
nuclear@0 267
nuclear@0 268 OVR::Net::BitStream bsOut, returnData;
nuclear@0 269 bsOut.Write(hmd);
nuclear@0 270 bsOut.Write(key);
nuclear@0 271 bsOut.Write(default_val);
nuclear@0 272 if (!GetRPC1()->CallBlocking("GetNumberValue_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 273 {
nuclear@0 274 return default_val;
nuclear@0 275 }
nuclear@0 276 double out = 0.;
nuclear@0 277 returnData.Read(out);
nuclear@0 278 return out;
nuclear@0 279 }
nuclear@0 280 int NetClient::GetNumberValues(VirtualHmdId hmd, const char* key, double* values, int num_vals)
nuclear@0 281 {
nuclear@0 282 if (!IsConnected(true, true))
nuclear@0 283 {
nuclear@0 284 return 0;
nuclear@0 285 }
nuclear@0 286
nuclear@0 287 OVR::Net::BitStream bsOut, returnData;
nuclear@0 288 bsOut.Write(hmd);
nuclear@0 289 bsOut.Write(key);
nuclear@0 290
nuclear@0 291 int32_t w = (int32_t)num_vals;
nuclear@0 292 bsOut.Write(w);
nuclear@0 293
nuclear@0 294 if (!GetRPC1()->CallBlocking("GetNumberValues_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 295 {
nuclear@0 296 return 0;
nuclear@0 297 }
nuclear@0 298
nuclear@0 299 int32_t out = 0;
nuclear@0 300 if (!returnData.Read(out))
nuclear@0 301 {
nuclear@0 302 OVR_ASSERT(false);
nuclear@0 303 }
nuclear@0 304 OVR_ASSERT(out >= 0 && out <= num_vals);
nuclear@0 305 if (out < 0)
nuclear@0 306 {
nuclear@0 307 out = 0;
nuclear@0 308 }
nuclear@0 309 else if (out > num_vals)
nuclear@0 310 {
nuclear@0 311 out = num_vals;
nuclear@0 312 }
nuclear@0 313
nuclear@0 314 for (int i = 0; i < out && i < num_vals; i++)
nuclear@0 315 {
nuclear@0 316 if (!returnData.Read(values[i]))
nuclear@0 317 {
nuclear@0 318 return i;
nuclear@0 319 }
nuclear@0 320 }
nuclear@0 321
nuclear@0 322 return out;
nuclear@0 323 }
nuclear@0 324
nuclear@0 325 bool NetClient::SetStringValue(VirtualHmdId hmd, const char* key, const char* val)
nuclear@0 326 {
nuclear@0 327 if (!IsConnected(true, true))
nuclear@0 328 {
nuclear@0 329 return false;
nuclear@0 330 }
nuclear@0 331
nuclear@0 332 OVR::Net::BitStream bsOut;
nuclear@0 333 bsOut.Write(hmd);
nuclear@0 334 bsOut.Write(key);
nuclear@0 335
nuclear@0 336 bsOut.Write(val);
nuclear@0 337
nuclear@0 338 if (!GetRPC1()->Signal("SetStringValue_1", &bsOut, GetSession()->GetConnectionAtIndex(0)))
nuclear@0 339 {
nuclear@0 340 return false;
nuclear@0 341 }
nuclear@0 342
nuclear@0 343 return true;
nuclear@0 344 }
nuclear@0 345
nuclear@0 346 bool NetClient::SetBoolValue(VirtualHmdId hmd, const char* key, bool val)
nuclear@0 347 {
nuclear@0 348 if (!IsConnected(true, true))
nuclear@0 349 {
nuclear@0 350 return false;
nuclear@0 351 }
nuclear@0 352
nuclear@0 353 OVR::Net::BitStream bsOut;
nuclear@0 354 bsOut.Write(hmd);
nuclear@0 355 bsOut.Write(key);
nuclear@0 356
nuclear@0 357 uint8_t b = val ? 1 : 0;
nuclear@0 358 bsOut.Write(b);
nuclear@0 359
nuclear@0 360 if (!GetRPC1()->Signal("SetBoolValue_1", &bsOut, GetSession()->GetConnectionAtIndex(0)))
nuclear@0 361 {
nuclear@0 362 return false;
nuclear@0 363 }
nuclear@0 364
nuclear@0 365 return true;
nuclear@0 366 }
nuclear@0 367
nuclear@0 368 bool NetClient::SetIntValue(VirtualHmdId hmd, const char* key, int val)
nuclear@0 369 {
nuclear@0 370 if (!IsConnected(true, true))
nuclear@0 371 {
nuclear@0 372 return false;
nuclear@0 373 }
nuclear@0 374
nuclear@0 375 OVR::Net::BitStream bsOut;
nuclear@0 376 bsOut.Write(hmd);
nuclear@0 377 bsOut.Write(key);
nuclear@0 378
nuclear@0 379 int32_t w = (int32_t)val;
nuclear@0 380 bsOut.Write(w);
nuclear@0 381
nuclear@0 382 if (!GetRPC1()->Signal("SetIntValue_1", &bsOut, GetSession()->GetConnectionAtIndex(0)))
nuclear@0 383 {
nuclear@0 384 return false;
nuclear@0 385 }
nuclear@0 386
nuclear@0 387 return true;
nuclear@0 388 }
nuclear@0 389
nuclear@0 390 bool NetClient::SetNumberValue(VirtualHmdId hmd, const char* key, double val)
nuclear@0 391 {
nuclear@0 392 if (!IsConnected(true, true))
nuclear@0 393 {
nuclear@0 394 return false;
nuclear@0 395 }
nuclear@0 396
nuclear@0 397 OVR::Net::BitStream bsOut;
nuclear@0 398 bsOut.Write(hmd);
nuclear@0 399 bsOut.Write(key);
nuclear@0 400
nuclear@0 401 bsOut.Write(val);
nuclear@0 402
nuclear@0 403 if (!GetRPC1()->Signal("SetNumberValue_1", &bsOut, GetSession()->GetConnectionAtIndex(0)))
nuclear@0 404 {
nuclear@0 405 return false;
nuclear@0 406 }
nuclear@0 407
nuclear@0 408 return true;
nuclear@0 409 }
nuclear@0 410
nuclear@0 411 bool NetClient::SetNumberValues(VirtualHmdId hmd, const char* key, const double* vals, int num_vals)
nuclear@0 412 {
nuclear@0 413 if (!IsConnected(true, true))
nuclear@0 414 {
nuclear@0 415 return false;
nuclear@0 416 }
nuclear@0 417
nuclear@0 418 OVR::Net::BitStream bsOut;
nuclear@0 419 bsOut.Write(hmd);
nuclear@0 420 bsOut.Write(key);
nuclear@0 421
nuclear@0 422 int32_t w_count = (int32_t)num_vals;
nuclear@0 423 bsOut.Write(w_count);
nuclear@0 424
nuclear@0 425 for (int i = 0; i < num_vals; i++)
nuclear@0 426 {
nuclear@0 427 bsOut.Write(vals[i]);
nuclear@0 428 }
nuclear@0 429
nuclear@0 430 if (!GetRPC1()->Signal("SetNumberValues_1", &bsOut, GetSession()->GetConnectionAtIndex(0)))
nuclear@0 431 {
nuclear@0 432 return false;
nuclear@0 433 }
nuclear@0 434
nuclear@0 435 return true;
nuclear@0 436 }
nuclear@0 437
nuclear@0 438 int NetClient::Hmd_Detect()
nuclear@0 439 {
nuclear@0 440 if (!IsConnected(true, false))
nuclear@0 441 {
nuclear@0 442 return 0;
nuclear@0 443 }
nuclear@0 444
nuclear@0 445 // If using edge-triggered HMD counting,
nuclear@0 446 if (EdgeTriggeredHMDCount)
nuclear@0 447 {
nuclear@0 448 // Return the last update from the server
nuclear@0 449 return HMDCount;
nuclear@0 450 }
nuclear@0 451
nuclear@0 452 // Otherwise: We need to ask the first time
nuclear@0 453
nuclear@0 454 OVR::Net::BitStream bsOut, returnData;
nuclear@0 455
nuclear@0 456 if (!GetRPC1()->CallBlocking("Hmd_Detect_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 457 {
nuclear@0 458 return 0;
nuclear@0 459 }
nuclear@0 460
nuclear@0 461 int32_t out = 0;
nuclear@0 462 if (!returnData.Read(out))
nuclear@0 463 {
nuclear@0 464 OVR_ASSERT(false);
nuclear@0 465 }
nuclear@0 466 HMDCount = out;
nuclear@0 467 EdgeTriggeredHMDCount = true;
nuclear@0 468 return out;
nuclear@0 469 }
nuclear@0 470
nuclear@0 471 bool NetClient::Hmd_Create(int index, HMDNetworkInfo* netInfo)
nuclear@0 472 {
nuclear@0 473 if (!IsConnected(true, true))
nuclear@0 474 {
nuclear@0 475 return false;
nuclear@0 476 }
nuclear@0 477
nuclear@0 478 OVR::Net::BitStream bsOut, returnData;
nuclear@0 479
nuclear@0 480 int32_t w = (int32_t)index;
nuclear@0 481 bsOut.Write(w);
nuclear@0 482
nuclear@0 483 // Need the Pid for driver mode
nuclear@0 484 pid_t pid = GetCurrentProcessId();
nuclear@0 485 bsOut.Write(pid);
nuclear@0 486
nuclear@0 487 if (!GetRPC1()->CallBlocking("Hmd_Create_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 488 {
nuclear@0 489 return false;
nuclear@0 490 }
nuclear@0 491
nuclear@0 492 return netInfo->Deserialize(&returnData);
nuclear@0 493 }
nuclear@0 494
nuclear@0 495 bool NetClient::GetDriverMode(bool& driverInstalled, bool& compatMode, bool& hideDK1Mode)
nuclear@0 496 {
nuclear@0 497 if (!IsConnected(true, true))
nuclear@0 498 {
nuclear@0 499 return false;
nuclear@0 500 }
nuclear@0 501
nuclear@0 502 OVR::Net::BitStream bsOut, returnData;
nuclear@0 503
nuclear@0 504 bsOut.Write(InvalidVirtualHmdId);
nuclear@0 505
nuclear@0 506 if (!GetRPC1()->CallBlocking("GetDriverMode_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 507 {
nuclear@0 508 return false;
nuclear@0 509 }
nuclear@0 510
nuclear@0 511 int32_t w_driverInstalled = 0;
nuclear@0 512 int32_t w_compatMode = 0;
nuclear@0 513 int32_t w_hideDK1Mode = 0;
nuclear@0 514 returnData.Read(w_driverInstalled);
nuclear@0 515 returnData.Read(w_compatMode);
nuclear@0 516 if (!returnData.Read(w_hideDK1Mode))
nuclear@0 517 {
nuclear@0 518 return false;
nuclear@0 519 }
nuclear@0 520
nuclear@0 521 driverInstalled = w_driverInstalled != 0;
nuclear@0 522 compatMode = w_compatMode != 0;
nuclear@0 523 hideDK1Mode = w_hideDK1Mode != 0;
nuclear@0 524 return true;
nuclear@0 525 }
nuclear@0 526
nuclear@0 527 bool NetClient::SetDriverMode(bool compatMode, bool hideDK1Mode)
nuclear@0 528 {
nuclear@0 529 if (!IsConnected(true, true))
nuclear@0 530 {
nuclear@0 531 return false;
nuclear@0 532 }
nuclear@0 533
nuclear@0 534 OVR::Net::BitStream bsOut, returnData;
nuclear@0 535
nuclear@0 536 bsOut.Write(InvalidVirtualHmdId);
nuclear@0 537
nuclear@0 538 int32_t w_compatMode, w_hideDK1Mode;
nuclear@0 539 w_compatMode = compatMode ? 1 : 0;
nuclear@0 540 w_hideDK1Mode = hideDK1Mode ? 1 : 0;
nuclear@0 541 bsOut.Write(w_compatMode);
nuclear@0 542 bsOut.Write(w_hideDK1Mode);
nuclear@0 543
nuclear@0 544 if (!GetRPC1()->CallBlocking("SetDriverMode_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 545 {
nuclear@0 546 return false;
nuclear@0 547 }
nuclear@0 548
nuclear@0 549 int32_t out = 0;
nuclear@0 550 if (!returnData.Read(out))
nuclear@0 551 {
nuclear@0 552 OVR_ASSERT(false);
nuclear@0 553 return false;
nuclear@0 554 }
nuclear@0 555
nuclear@0 556 return out != 0;
nuclear@0 557 }
nuclear@0 558
nuclear@0 559 bool NetClient::Hmd_AttachToWindow(VirtualHmdId hmd, void* hWindow)
nuclear@0 560 {
nuclear@0 561 if (!IsConnected(false, false))
nuclear@0 562 {
nuclear@0 563 return false;
nuclear@0 564 }
nuclear@0 565
nuclear@0 566 OVR::Net::BitStream bsOut;
nuclear@0 567 bsOut.Write(hmd);
nuclear@0 568
nuclear@0 569 #ifdef OVR_OS_LINUX
nuclear@0 570 if (hWindow == NULL)
nuclear@0 571 {
nuclear@0 572 return false;
nuclear@0 573 }
nuclear@0 574 unsigned long hWinWord = *(unsigned long *)hWindow;
nuclear@0 575 #else
nuclear@0 576 UInt64 hWinWord = (UPInt)hWindow;
nuclear@0 577 #endif
nuclear@0 578 bsOut.Write(hWinWord);
nuclear@0 579
nuclear@0 580 if (!GetRPC1()->CallBlocking("Hmd_AttachToWindow_1", &bsOut, GetSession()->GetConnectionAtIndex(0)))
nuclear@0 581 {
nuclear@0 582 return false;
nuclear@0 583 }
nuclear@0 584
nuclear@0 585 return true;
nuclear@0 586 }
nuclear@0 587
nuclear@0 588 void NetClient::Hmd_Release(VirtualHmdId hmd)
nuclear@0 589 {
nuclear@0 590 if (!IsConnected(false, false))
nuclear@0 591 {
nuclear@0 592 return;
nuclear@0 593 }
nuclear@0 594
nuclear@0 595 OVR::Net::BitStream bsOut;
nuclear@0 596 bsOut.Write(hmd);
nuclear@0 597 bool result = GetRPC1()->CallBlocking("Hmd_Release_1", &bsOut, GetSession()->GetConnectionAtIndex(0));
nuclear@0 598 OVR_ASSERT_AND_UNUSED(result, result);
nuclear@0 599 }
nuclear@0 600
nuclear@0 601 void NetClient::SetLastError(String str)
nuclear@0 602 {
nuclear@0 603 Hmd_GetLastError_Str = str;
nuclear@0 604 }
nuclear@0 605
nuclear@0 606 // Last string is cached locally.
nuclear@0 607 const char* NetClient::Hmd_GetLastError(VirtualHmdId hmd)
nuclear@0 608 {
nuclear@0 609 if (hmd == InvalidVirtualHmdId || !IsConnected(false, false))
nuclear@0 610 {
nuclear@0 611 return Hmd_GetLastError_Str.ToCStr();
nuclear@0 612 }
nuclear@0 613
nuclear@0 614 OVR::Net::BitStream bsOut, returnData;
nuclear@0 615 bsOut.Write(hmd);
nuclear@0 616 if (!GetRPC1()->CallBlocking("Hmd_GetLastError_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 617 {
nuclear@0 618 return Hmd_GetLastError_Str.ToCStr();
nuclear@0 619 }
nuclear@0 620 if (!returnData.Read(Hmd_GetLastError_Str))
nuclear@0 621 {
nuclear@0 622 OVR_ASSERT(false);
nuclear@0 623 }
nuclear@0 624 return Hmd_GetLastError_Str.ToCStr();
nuclear@0 625 }
nuclear@0 626
nuclear@0 627
nuclear@0 628 // Fills in description about HMD; this is the same as filled in by ovrHmd_Create.
nuclear@0 629 // The actual descriptor is a par
nuclear@0 630 bool NetClient::Hmd_GetHmdInfo(VirtualHmdId hmd, HMDInfo* hmdInfo)
nuclear@0 631 {
nuclear@0 632 if (!IsConnected(false, false))
nuclear@0 633 {
nuclear@0 634 return false;
nuclear@0 635 }
nuclear@0 636
nuclear@0 637 OVR::Net::BitStream bsOut, returnData;
nuclear@0 638 bsOut.Write(hmd);
nuclear@0 639 if (!GetRPC1()->CallBlocking("Hmd_GetHmdInfo_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 640 {
nuclear@0 641 return false;
nuclear@0 642 }
nuclear@0 643
nuclear@0 644 return NetSessionCommon::DeserializeHMDInfo(&returnData, hmdInfo);
nuclear@0 645 }
nuclear@0 646
nuclear@0 647
nuclear@0 648 //-------------------------------------------------------------------------------------
nuclear@0 649 unsigned int NetClient::Hmd_GetEnabledCaps(VirtualHmdId hmd)
nuclear@0 650 {
nuclear@0 651 if (!IsConnected(false, false))
nuclear@0 652 {
nuclear@0 653 return 0;
nuclear@0 654 }
nuclear@0 655
nuclear@0 656 OVR::Net::BitStream bsOut, returnData;
nuclear@0 657 bsOut.Write(hmd);
nuclear@0 658 if (!GetRPC1()->CallBlocking("Hmd_GetEnabledCaps_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 659 {
nuclear@0 660 return 0;
nuclear@0 661 }
nuclear@0 662
nuclear@0 663 uint32_t c = 0;
nuclear@0 664 if (!returnData.Read(c))
nuclear@0 665 {
nuclear@0 666 OVR_ASSERT(false);
nuclear@0 667 }
nuclear@0 668 return c;
nuclear@0 669 }
nuclear@0 670
nuclear@0 671 // Returns new caps after modification
nuclear@0 672 unsigned int NetClient::Hmd_SetEnabledCaps(VirtualHmdId hmd, unsigned int hmdCaps)
nuclear@0 673 {
nuclear@0 674 if (!IsConnected(false, false))
nuclear@0 675 {
nuclear@0 676 return 0;
nuclear@0 677 }
nuclear@0 678
nuclear@0 679 OVR::Net::BitStream bsOut, returnData;
nuclear@0 680 bsOut.Write(hmd);
nuclear@0 681
nuclear@0 682 uint32_t c = (uint32_t)hmdCaps;
nuclear@0 683 bsOut.Write(c);
nuclear@0 684
nuclear@0 685 if (!GetRPC1()->CallBlocking("Hmd_SetEnabledCaps_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 686 {
nuclear@0 687 return 0;
nuclear@0 688 }
nuclear@0 689
nuclear@0 690 c = 0;
nuclear@0 691 if (!returnData.Read(c))
nuclear@0 692 {
nuclear@0 693 OVR_ASSERT(false);
nuclear@0 694 }
nuclear@0 695 return c;
nuclear@0 696 }
nuclear@0 697
nuclear@0 698
nuclear@0 699 //-------------------------------------------------------------------------------------
nuclear@0 700 // *** Tracking Setup
nuclear@0 701
nuclear@0 702 bool NetClient::Hmd_ConfigureTracking(VirtualHmdId hmd, unsigned supportedCaps, unsigned requiredCaps)
nuclear@0 703 {
nuclear@0 704 if (!IsConnected(false, false))
nuclear@0 705 {
nuclear@0 706 return false;
nuclear@0 707 }
nuclear@0 708
nuclear@0 709 OVR::Net::BitStream bsOut, returnData;
nuclear@0 710 bsOut.Write(hmd);
nuclear@0 711
nuclear@0 712 uint32_t w_sc = supportedCaps;
nuclear@0 713 bsOut.Write(w_sc);
nuclear@0 714 uint32_t w_rc = requiredCaps;
nuclear@0 715 bsOut.Write(w_rc);
nuclear@0 716
nuclear@0 717 if (!GetRPC1()->CallBlocking("Hmd_ConfigureTracking_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 718 {
nuclear@0 719 return false;
nuclear@0 720 }
nuclear@0 721
nuclear@0 722 uint8_t b;
nuclear@0 723 if (!returnData.Read(b))
nuclear@0 724 {
nuclear@0 725 OVR_ASSERT(false);
nuclear@0 726 }
nuclear@0 727
nuclear@0 728 return b != 0;
nuclear@0 729 }
nuclear@0 730
nuclear@0 731
nuclear@0 732 void NetClient::Hmd_ResetTracking(VirtualHmdId hmd)
nuclear@0 733 {
nuclear@0 734 if (!IsConnected(false, false))
nuclear@0 735 {
nuclear@0 736 return;
nuclear@0 737 }
nuclear@0 738
nuclear@0 739 OVR::Net::BitStream bsOut;
nuclear@0 740 bsOut.Write(hmd);
nuclear@0 741 if (!GetRPC1()->CallBlocking("Hmd_ResetTracking_1", &bsOut, GetSession()->GetConnectionAtIndex(0)))
nuclear@0 742 {
nuclear@0 743 return;
nuclear@0 744 }
nuclear@0 745 }
nuclear@0 746
nuclear@0 747 bool NetClient::LatencyUtil_ProcessInputs(double startTestSeconds, unsigned char rgbColorOut[3])
nuclear@0 748 {
nuclear@0 749 if (!IsConnected(false, false))
nuclear@0 750 {
nuclear@0 751 return false;
nuclear@0 752 }
nuclear@0 753
nuclear@0 754 if (!LatencyTesterAvailable)
nuclear@0 755 {
nuclear@0 756 return false;
nuclear@0 757 }
nuclear@0 758
nuclear@0 759 OVR::Net::BitStream bsOut, returnData;
nuclear@0 760 bsOut.Write(startTestSeconds);
nuclear@0 761 if (!GetRPC1()->CallBlocking("LatencyUtil_ProcessInputs_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 762 {
nuclear@0 763 return false;
nuclear@0 764 }
nuclear@0 765
nuclear@0 766 uint8_t u;
nuclear@0 767 returnData.Read(u);
nuclear@0 768 rgbColorOut[0] = u;
nuclear@0 769 returnData.Read(u);
nuclear@0 770 rgbColorOut[1] = u;
nuclear@0 771 if (!returnData.Read(u))
nuclear@0 772 {
nuclear@0 773 return false;
nuclear@0 774 }
nuclear@0 775 rgbColorOut[2] = u;
nuclear@0 776
nuclear@0 777 return true;
nuclear@0 778 }
nuclear@0 779
nuclear@0 780 const char* NetClient::LatencyUtil_GetResultsString()
nuclear@0 781 {
nuclear@0 782 if (!IsConnected(false, false))
nuclear@0 783 {
nuclear@0 784 return NULL;
nuclear@0 785 }
nuclear@0 786
nuclear@0 787 OVR::Net::BitStream bsOut, returnData;
nuclear@0 788 if (!GetRPC1()->CallBlocking("LatencyUtil_GetResultsString_1", &bsOut, GetSession()->GetConnectionAtIndex(0), &returnData))
nuclear@0 789 {
nuclear@0 790 return NULL;
nuclear@0 791 }
nuclear@0 792
nuclear@0 793 if (!returnData.Read(LatencyUtil_GetResultsString_Str))
nuclear@0 794 {
nuclear@0 795 OVR_ASSERT(false);
nuclear@0 796 }
nuclear@0 797
nuclear@0 798 return LatencyUtil_GetResultsString_Str.ToCStr();
nuclear@0 799 }
nuclear@0 800
nuclear@0 801 bool NetClient::ShutdownServer()
nuclear@0 802 {
nuclear@0 803 if (!IsConnected(false, false))
nuclear@0 804 {
nuclear@0 805 return false;
nuclear@0 806 }
nuclear@0 807
nuclear@0 808 OVR::Net::BitStream bsOut;
nuclear@0 809 GetRPC1()->BroadcastSignal("Shutdown_1", &bsOut);
nuclear@0 810
nuclear@0 811 return true;
nuclear@0 812 }
nuclear@0 813
nuclear@0 814
nuclear@0 815 //// Push Notifications:
nuclear@0 816
nuclear@0 817 void NetClient::registerRPC()
nuclear@0 818 {
nuclear@0 819 #define RPC_REGISTER_SLOT(observerScope, functionName) \
nuclear@0 820 observerScope.SetHandler(OVR::Net::Plugins::RPCSlot::FromMember<NetClient, &NetClient::functionName>(this)); pRPC->RegisterSlot(OVR_STRINGIZE(functionName), observerScope);
nuclear@0 821
nuclear@0 822 // Register RPC functions:
nuclear@0 823 RPC_REGISTER_SLOT(InitialServerStateScope, InitialServerState_1);
nuclear@0 824 RPC_REGISTER_SLOT(LatencyTesterAvailableScope, LatencyTesterAvailable_1);
nuclear@0 825 RPC_REGISTER_SLOT(DefaultLogOutputScope, DefaultLogOutput_1);
nuclear@0 826 RPC_REGISTER_SLOT(HMDCountUpdateScope, HMDCountUpdate_1);
nuclear@0 827 }
nuclear@0 828
nuclear@0 829 void NetClient::InitialServerState_1(BitStream* userData, ReceivePayload* pPayload)
nuclear@0 830 {
nuclear@0 831 LatencyTesterAvailable_1(userData, pPayload);
nuclear@0 832 }
nuclear@0 833
nuclear@0 834 void NetClient::LatencyTesterAvailable_1(BitStream* userData, ReceivePayload* pPayload)
nuclear@0 835 {
nuclear@0 836 OVR_UNUSED(pPayload);
nuclear@0 837
nuclear@0 838 uint8_t b = 0;
nuclear@0 839 if (!userData->Read(b))
nuclear@0 840 {
nuclear@0 841 OVR_ASSERT(false);
nuclear@0 842 return;
nuclear@0 843 }
nuclear@0 844
nuclear@0 845 LatencyTesterAvailable = (b != 0);
nuclear@0 846 }
nuclear@0 847
nuclear@0 848 void NetClient::DefaultLogOutput_1(BitStream* userData, ReceivePayload* pPayload)
nuclear@0 849 {
nuclear@0 850 OVR_UNUSED(pPayload);
nuclear@0 851
nuclear@0 852 String formattedText;
nuclear@0 853 LogMessageType messageType = Log_Text; // Will normally be overwritten below.
nuclear@0 854 userData->Read(messageType);
nuclear@0 855 if (userData->Read(formattedText))
nuclear@0 856 {
nuclear@0 857 if (OVR::Log::GetGlobalLog())
nuclear@0 858 {
nuclear@0 859 OVR::String logStr = "[From Service] ";
nuclear@0 860 logStr.AppendString(formattedText);
nuclear@0 861 OVR::Log::GetGlobalLog()->LogMessage(messageType, "%s", logStr.ToCStr());
nuclear@0 862 }
nuclear@0 863 }
nuclear@0 864 }
nuclear@0 865
nuclear@0 866 void NetClient::HMDCountUpdate_1(BitStream* userData, ReceivePayload* pPayload)
nuclear@0 867 {
nuclear@0 868 OVR_UNUSED(pPayload);
nuclear@0 869
nuclear@0 870 int32_t hmdCount = 0;
nuclear@0 871 if (!userData->Read(hmdCount))
nuclear@0 872 {
nuclear@0 873 OVR_ASSERT(false);
nuclear@0 874 return;
nuclear@0 875 }
nuclear@0 876
nuclear@0 877 HMDCount = hmdCount;
nuclear@0 878 EdgeTriggeredHMDCount = true;
nuclear@0 879 }
nuclear@0 880
nuclear@0 881
nuclear@0 882 }} // namespace OVR::Service