?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'public/release_candidate' into release
[CRYENGINE.git] / Code / CryEngine / CryAudioSystem / System.cpp
blob7f47690bfe899558354db05ed469bc060d06a26a
1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
2
3 #include "stdafx.h"
4 #include "System.h"
5 #include "Impl.h"
6 #include "PoolObject_impl.h"
7 #include "Managers.h"
8 #include "FileCacheManager.h"
9 #include "ListenerManager.h"
10 #include "EventListenerManager.h"
11 #include "XMLProcessor.h"
12 #include "SystemRequestData.h"
13 #include "ObjectRequestData.h"
14 #include "ListenerRequestData.h"
15 #include "CallbackRequestData.h"
16 #include "CVars.h"
17 #include "File.h"
18 #include "Listener.h"
19 #include "Object.h"
20 #include "LoseFocusTrigger.h"
21 #include "GetFocusTrigger.h"
22 #include "MuteAllTrigger.h"
23 #include "UnmuteAllTrigger.h"
24 #include "PauseAllTrigger.h"
25 #include "ResumeAllTrigger.h"
26 #include "Environment.h"
27 #include "Parameter.h"
28 #include "PreloadRequest.h"
29 #include "Setting.h"
30 #include "Switch.h"
31 #include "SwitchState.h"
32 #include "Trigger.h"
33 #include "TriggerInstance.h"
34 #include "Common/IObject.h"
35 #include <CrySystem/ITimer.h>
36 #include <CryString/CryPath.h>
37 #include <CryEntitySystem/IEntitySystem.h>
38 #include <CryMath/Cry_Camera.h>
39
40 #if defined(CRY_AUDIO_USE_OCCLUSION)
41 #include "PropagationProcessor.h"
42 #endif // CRY_AUDIO_USE_OCCLUSION
43
44 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
45 #include "PreviewTrigger.h"
46 #include "Debug.h"
47 #include "Common/Logger.h"
48 #include "Common/DebugStyle.h"
49 #include <CryRenderer/IRenderAuxGeom.h>
50 #endif // CRY_AUDIO_USE_DEBUG_CODE
51
52 namespace CryAudio
53 {
54 ContextId g_currentLevelContextId = InvalidContextId;
55
56 constexpr uint16 g_systemExecuteTriggerPoolSize = 4;
57 constexpr uint16 g_systemExecuteTriggerExPoolSize = 16;
58 constexpr uint16 g_systemExecuteTriggerWithCallbacksPoolSize = 16;
59 constexpr uint16 g_systemStopTriggerPoolSize = 4;
60 constexpr uint16 g_systemRegisterObjectPoolSize = 16;
61 constexpr uint16 g_systemReleaseObjectPoolSize = 16;
62 constexpr uint16 g_systemSetParameterPoolSize = 4;
63 constexpr uint16 g_systemSetSwitchStatePoolSize = 4;
64
65 constexpr uint16 g_objectExecuteTriggerPoolSize = 64;
66 constexpr uint16 g_objectExecuteTriggerWithCallbacksPoolSize = 16;
67 constexpr uint16 g_objectStopTriggerPoolSize = 128;
68 constexpr uint16 g_objectSetTransformationPoolSize = 128;
69 constexpr uint16 g_objectSetParameterPoolSize = 128;
70 constexpr uint16 g_objectSetSwitchStatePoolSize = 64;
71 constexpr uint16 g_objectSetCurrentEnvironmentsPoolSize = 16;
72 constexpr uint16 g_objectSetEnvironmentPoolSize = 64;
73 constexpr uint16 g_objectProcessPhysicsRayPoolSize = 128;
74
75 constexpr uint16 g_listenerSetTransformationPoolSize = 2;
76
77 constexpr uint16 g_callbackReportStartedTriggerConnectionInstancePoolSize = 64;
78 constexpr uint16 g_callbackReportFinishedTriggerConnectionInstancePoolSize = 128;
79 constexpr uint16 g_callbackReportFinishedTriggerInstancePoolSize = 128;
80 constexpr uint16 g_callbackReportTriggerConnectionInstanceCallbackPoolSize = 16;
81 constexpr uint16 g_callbackSendTriggerInstanceCallbackPoolSize = 16;
82 constexpr uint16 g_callbackReportPhysicalizedObjectPoolSize = 64;
83 constexpr uint16 g_callbackReportVirtualizedObjectPoolSize = 64;
84
85 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
86 enum class ELoggingOptions : EnumFlagsType
87 {
88 None,
89 Errors = BIT(6), // a
90 Warnings = BIT(7), // b
91 Comments = BIT(8), // c
92 };
93 CRY_CREATE_ENUM_FLAG_OPERATORS(ELoggingOptions);
94
95 enum class EDebugUpdateFilter : EnumFlagsType
96 {
97 None = 0,
98 FileCacheManager = BIT(0),
99 Contexts = BIT(1),
100 };
101 CRY_CREATE_ENUM_FLAG_OPERATORS(EDebugUpdateFilter);
102
103 struct SRequestCount final
104 {
105 uint16 requests = 0;
106
107 uint16 systemExecuteTrigger = 0;
108 uint16 systemExecuteTriggerEx = 0;
109 uint16 systemExecuteTriggerWithCallbacks = 0;
110 uint16 systemStopTrigger = 0;
111 uint16 systemRegisterObject = 0;
112 uint16 systemReleaseObject = 0;
113 uint16 systemSetParameter = 0;
114 uint16 systemSetSwitchState = 0;
115
116 uint16 objectExecuteTrigger = 0;
117 uint16 objectExecuteTriggerWithCallbacks = 0;
118 uint16 objectStopTrigger = 0;
119 uint16 objectSetTransformation = 0;
120 uint16 objectSetParameter = 0;
121 uint16 objectSetSwitchState = 0;
122 uint16 objectSetCurrentEnvironments = 0;
123 uint16 objectSetEnvironment = 0;
124 uint16 objectProcessPhysicsRay = 0;
125
126 uint16 listenerSetTransformation = 0;
127
128 uint16 callbackReportStartedriggerConnectionInstance = 0;
129 uint16 callbackReportFinishedTriggerConnectionInstance = 0;
130 uint16 callbackReportFinishedTriggerInstance = 0;
131 uint16 callbackReportTriggerConnectionInstanceCallback = 0;
132 uint16 callbackSendTriggerInstanceCallback = 0;
133 uint16 callbackReportPhysicalizedObject = 0;
134 uint16 callbackReportVirtualizedObject = 0;
135 };
136
137 SRequestCount g_requestsPerUpdate;
138 SRequestCount g_requestPeaks;
139 Debug::StateDrawInfo g_stateDrawInfo;
140
141 //////////////////////////////////////////////////////////////////////////
142 void CountRequestPerUpdate(CRequest const& request)
143 {
144 auto const pRequestData = request.GetData();
145
146 if (pRequestData != nullptr)
147 {
148 g_requestsPerUpdate.requests++;
149
150 switch (request.GetData()->requestType)
151 {
152 case ERequestType::SystemRequest:
153 {
154 auto const pBase = static_cast<SSystemRequestDataBase const*>(pRequestData);
155
156 switch (pBase->systemRequestType)
157 {
158 case ESystemRequestType::RegisterObject:
159 {
160 g_requestsPerUpdate.systemRegisterObject++;
161
162 break;
163 }
164 case ESystemRequestType::ReleaseObject:
165 {
166 g_requestsPerUpdate.systemReleaseObject++;
167
168 break;
169 }
170 case ESystemRequestType::ExecuteTrigger:
171 {
172 g_requestsPerUpdate.systemExecuteTrigger++;
173
174 break;
175 }
176 case ESystemRequestType::ExecuteTriggerEx:
177 {
178 g_requestsPerUpdate.systemExecuteTriggerEx++;
179
180 break;
181 }
182 case ESystemRequestType::ExecuteTriggerWithCallbacks:
183 {
184 g_requestsPerUpdate.systemExecuteTriggerWithCallbacks++;
185
186 break;
187 }
188 case ESystemRequestType::StopTrigger:
189 {
190 g_requestsPerUpdate.systemStopTrigger++;
191
192 break;
193 }
194 case ESystemRequestType::SetParameter:
195 {
196 g_requestsPerUpdate.systemSetParameter++;
197
198 break;
199 }
200 case ESystemRequestType::SetSwitchState:
201 {
202 g_requestsPerUpdate.systemSetSwitchState++;
203
204 break;
205 }
206 default:
207 {
208 break;
209 }
210 }
211
212 break;
213 }
214 case ERequestType::ObjectRequest:
215 {
216 auto const pBase = static_cast<SObjectRequestDataBase const*>(pRequestData);
217
218 switch (pBase->objectRequestType)
219 {
220 case EObjectRequestType::ExecuteTrigger:
221 {
222 g_requestsPerUpdate.objectExecuteTrigger++;
223
224 break;
225 }
226 case EObjectRequestType::ExecuteTriggerWithCallbacks:
227 {
228 g_requestsPerUpdate.objectExecuteTriggerWithCallbacks++;
229
230 break;
231 }
232 case EObjectRequestType::StopTrigger:
233 {
234 g_requestsPerUpdate.objectStopTrigger++;
235
236 break;
237 }
238 case EObjectRequestType::SetTransformation:
239 {
240 g_requestsPerUpdate.objectSetTransformation++;
241
242 break;
243 }
244 case EObjectRequestType::SetParameter:
245 {
246 g_requestsPerUpdate.objectSetParameter++;
247
248 break;
249 }
250 case EObjectRequestType::SetSwitchState:
251 {
252 g_requestsPerUpdate.objectSetSwitchState++;
253
254 break;
255 }
256 case EObjectRequestType::SetCurrentEnvironments:
257 {
258 g_requestsPerUpdate.objectSetCurrentEnvironments++;
259
260 break;
261 }
262 case EObjectRequestType::SetEnvironment:
263 {
264 g_requestsPerUpdate.objectSetEnvironment++;
265
266 break;
267 }
268 case EObjectRequestType::ProcessPhysicsRay:
269 {
270 g_requestsPerUpdate.objectProcessPhysicsRay++;
271
272 break;
273 }
274 default:
275 {
276 break;
277 }
278 }
279
280 break;
281 }
282 case ERequestType::ListenerRequest:
283 {
284 auto const pBase = static_cast<SListenerRequestDataBase const*>(pRequestData);
285
286 if (pBase->listenerRequestType == EListenerRequestType::SetTransformation)
287 {
288 g_requestsPerUpdate.listenerSetTransformation++;
289 }
290
291 break;
292 }
293 case ERequestType::CallbackRequest:
294 {
295 auto const pBase = static_cast<SCallbackRequestDataBase const*>(pRequestData);
296
297 switch (pBase->callbackRequestType)
298 {
299 case ECallbackRequestType::ReportStartedTriggerConnectionInstance:
300 {
301 g_requestsPerUpdate.callbackReportStartedriggerConnectionInstance++;
302
303 break;
304 }
305 case ECallbackRequestType::ReportFinishedTriggerConnectionInstance:
306 {
307 g_requestsPerUpdate.callbackReportFinishedTriggerConnectionInstance++;
308
309 break;
310 }
311 case ECallbackRequestType::ReportFinishedTriggerInstance:
312 {
313 g_requestsPerUpdate.callbackReportFinishedTriggerInstance++;
314
315 break;
316 }
317 case ECallbackRequestType::ReportTriggerConnectionInstanceCallback:
318 {
319 g_requestsPerUpdate.callbackReportTriggerConnectionInstanceCallback++;
320
321 break;
322 }
323 case ECallbackRequestType::SendTriggerInstanceCallback:
324 {
325 g_requestsPerUpdate.callbackSendTriggerInstanceCallback++;
326
327 break;
328 }
329 case ECallbackRequestType::ReportPhysicalizedObject:
330 {
331 g_requestsPerUpdate.callbackReportPhysicalizedObject++;
332
333 break;
334 }
335 case ECallbackRequestType::ReportVirtualizedObject:
336 {
337 g_requestsPerUpdate.callbackReportVirtualizedObject++;
338
339 break;
340 }
341 default:
342 {
343 break;
344 }
345 }
346
347 break;
348 }
349 default:
350 {
351 break;
352 }
353 }
354 }
355 }
356
357 //////////////////////////////////////////////////////////////////////////
358 void SetRequestCountPeak()
359 {
360 g_requestPeaks.requests = std::max(g_requestPeaks.requests, g_requestsPerUpdate.requests);
361
362 g_requestPeaks.systemRegisterObject = std::max(g_requestPeaks.systemRegisterObject, g_requestsPerUpdate.systemRegisterObject);
363 g_requestPeaks.systemReleaseObject = std::max(g_requestPeaks.systemReleaseObject, g_requestsPerUpdate.systemReleaseObject);
364 g_requestPeaks.systemExecuteTrigger = std::max(g_requestPeaks.systemExecuteTrigger, g_requestsPerUpdate.systemExecuteTrigger);
365 g_requestPeaks.systemExecuteTriggerEx = std::max(g_requestPeaks.systemExecuteTriggerEx, g_requestsPerUpdate.systemExecuteTriggerEx);
366 g_requestPeaks.systemExecuteTriggerWithCallbacks = std::max(g_requestPeaks.systemExecuteTriggerWithCallbacks, g_requestsPerUpdate.systemExecuteTriggerWithCallbacks);
367 g_requestPeaks.systemStopTrigger = std::max(g_requestPeaks.systemStopTrigger, g_requestsPerUpdate.systemStopTrigger);
368 g_requestPeaks.systemSetParameter = std::max(g_requestPeaks.systemSetParameter, g_requestsPerUpdate.systemSetParameter);
369 g_requestPeaks.systemSetSwitchState = std::max(g_requestPeaks.systemSetSwitchState, g_requestsPerUpdate.systemSetSwitchState);
370
371 g_requestPeaks.objectExecuteTrigger = std::max(g_requestPeaks.objectExecuteTrigger, g_requestsPerUpdate.objectExecuteTrigger);
372 g_requestPeaks.objectExecuteTriggerWithCallbacks = std::max(g_requestPeaks.objectExecuteTriggerWithCallbacks, g_requestsPerUpdate.objectExecuteTriggerWithCallbacks);
373 g_requestPeaks.objectStopTrigger = std::max(g_requestPeaks.objectStopTrigger, g_requestsPerUpdate.objectStopTrigger);
374 g_requestPeaks.objectSetTransformation = std::max(g_requestPeaks.objectSetTransformation, g_requestsPerUpdate.objectSetTransformation);
375 g_requestPeaks.objectSetParameter = std::max(g_requestPeaks.objectSetParameter, g_requestsPerUpdate.objectSetParameter);
376 g_requestPeaks.objectSetSwitchState = std::max(g_requestPeaks.objectSetSwitchState, g_requestsPerUpdate.objectSetSwitchState);
377 g_requestPeaks.objectSetCurrentEnvironments = std::max(g_requestPeaks.objectSetCurrentEnvironments, g_requestsPerUpdate.objectSetCurrentEnvironments);
378 g_requestPeaks.objectSetEnvironment = std::max(g_requestPeaks.objectSetEnvironment, g_requestsPerUpdate.objectSetEnvironment);
379 g_requestPeaks.objectProcessPhysicsRay = std::max(g_requestPeaks.objectProcessPhysicsRay, g_requestsPerUpdate.objectProcessPhysicsRay);
380
381 g_requestPeaks.listenerSetTransformation = std::max(g_requestPeaks.listenerSetTransformation, g_requestsPerUpdate.listenerSetTransformation);
382
383 g_requestPeaks.callbackReportStartedriggerConnectionInstance = std::max(g_requestPeaks.callbackReportStartedriggerConnectionInstance, g_requestsPerUpdate.callbackReportStartedriggerConnectionInstance);
384 g_requestPeaks.callbackReportFinishedTriggerConnectionInstance = std::max(g_requestPeaks.callbackReportFinishedTriggerConnectionInstance, g_requestsPerUpdate.callbackReportFinishedTriggerConnectionInstance);
385 g_requestPeaks.callbackReportFinishedTriggerInstance = std::max(g_requestPeaks.callbackReportFinishedTriggerInstance, g_requestsPerUpdate.callbackReportFinishedTriggerInstance);
386 g_requestPeaks.callbackReportTriggerConnectionInstanceCallback = std::max(g_requestPeaks.callbackReportTriggerConnectionInstanceCallback, g_requestsPerUpdate.callbackReportTriggerConnectionInstanceCallback);
387 g_requestPeaks.callbackSendTriggerInstanceCallback = std::max(g_requestPeaks.callbackSendTriggerInstanceCallback, g_requestsPerUpdate.callbackSendTriggerInstanceCallback);
388 g_requestPeaks.callbackReportPhysicalizedObject = std::max(g_requestPeaks.callbackReportPhysicalizedObject, g_requestsPerUpdate.callbackReportPhysicalizedObject);
389 g_requestPeaks.callbackReportVirtualizedObject = std::max(g_requestPeaks.callbackReportVirtualizedObject, g_requestsPerUpdate.callbackReportVirtualizedObject);
390
391 ZeroStruct(g_requestsPerUpdate);
392 }
393
394 //////////////////////////////////////////////////////////////////////////
395 bool ExecuteDefaultTrigger(ControlId const id)
396 {
397 bool wasSuccess = true;
398
399 switch (id)
400 {
401 case g_loseFocusTriggerId:
402 {
403 g_loseFocusTrigger.Execute();
404 break;
405 }
406 case g_getFocusTriggerId:
407 {
408 g_getFocusTrigger.Execute();
409 break;
410 }
411 case g_muteAllTriggerId:
412 {
413 g_muteAllTrigger.Execute();
414 break;
415 }
416 case g_unmuteAllTriggerId:
417 {
418 g_unmuteAllTrigger.Execute();
419 break;
420 }
421 case g_pauseAllTriggerId:
422 {
423 g_pauseAllTrigger.Execute();
424 break;
425 }
426 case g_resumeAllTriggerId:
427 {
428 g_resumeAllTrigger.Execute();
429 break;
430 }
431 default:
432 {
433 wasSuccess = false;
434 break;
435 }
436 }
437
438 return wasSuccess;
439 }
440
441 ///////////////////////////////////////////////////////////////////////////
442 void ForceGlobalDataImplRefresh()
443 {
444 // Parameters
445 for (auto const& parameterPair : g_parameters)
446 {
447 CParameter const* const pParameter = stl::find_in_map(g_parameterLookup, parameterPair.first, nullptr);
448
449 if (pParameter != nullptr)
450 {
451 pParameter->Set(parameterPair.second);
452 }
453 else
454 {
455 Cry::Audio::Log(ELogType::Warning, "Parameter \"%u\" does not exist!", parameterPair.first);
456 }
457 }
458
459 for (auto const& parameterPair : g_parametersGlobally)
460 {
461 CParameter const* const pParameter = stl::find_in_map(g_parameterLookup, parameterPair.first, nullptr);
462
463 if (pParameter != nullptr)
464 {
465 pParameter->SetGlobally(parameterPair.second);
466 }
467 else
468 {
469 Cry::Audio::Log(ELogType::Warning, "Parameter \"%u\" does not exist!", parameterPair.first);
470 }
471 }
472
473 // Switches
474 for (auto const& switchPair : g_switchStates)
475 {
476 CSwitch const* const pSwitch = stl::find_in_map(g_switchLookup, switchPair.first, nullptr);
477
478 if (pSwitch != nullptr)
479 {
480 CSwitchState const* const pState = stl::find_in_map(pSwitch->GetStates(), switchPair.second, nullptr);
481
482 if (pState != nullptr)
483 {
484 pState->Set();
485 }
486 }
487 }
488
489 for (auto const& switchPair : g_switchStatesGlobally)
490 {
491 CSwitch const* const pSwitch = stl::find_in_map(g_switchLookup, switchPair.first, nullptr);
492
493 if (pSwitch != nullptr)
494 {
495 CSwitchState const* const pState = stl::find_in_map(pSwitch->GetStates(), switchPair.second, nullptr);
496
497 if (pState != nullptr)
498 {
499 pState->SetGlobally();
500 }
501 }
502 }
503
504 uint16 triggerCounter = 0;
505 // Last re-execute its active triggers.
506 for (auto const& triggerInstancePair : g_triggerInstances)
507 {
508 CTrigger const* const pTrigger = stl::find_in_map(g_triggerLookup, triggerInstancePair.second->GetTriggerId(), nullptr);
509
510 if (pTrigger != nullptr)
511 {
512 pTrigger->Execute(triggerInstancePair.first, triggerInstancePair.second, triggerCounter);
513 ++triggerCounter;
514 }
515 else if (!ExecuteDefaultTrigger(triggerInstancePair.second->GetTriggerId()))
516 {
517 Cry::Audio::Log(ELogType::Warning, "Trigger \"%u\" does not exist!", triggerInstancePair.second->GetTriggerId());
518 }
519 }
520 }
521
522 //////////////////////////////////////////////////////////////////////////
523 void UpdateContextDebugInfo(char const* const szDebugFilter)
524 {
525 g_contextDebugInfo.clear();
526
527 CryFixedStringT<MaxControlNameLength> lowerCaseSearchString(szDebugFilter);
528 lowerCaseSearchString.MakeLower();
529
530 for (auto const& contextPair : g_contextInfo)
531 {
532 if (contextPair.second.isRegistered)
533 {
534 char const* const szContextName = contextPair.first.c_str();
535 CryFixedStringT<MaxControlNameLength> lowerCaseContextName(szContextName);
536 lowerCaseContextName.MakeLower();
537
538 if ((lowerCaseSearchString.empty() || (lowerCaseSearchString == "0")) || (lowerCaseContextName.find(lowerCaseSearchString) != CryFixedStringT<MaxControlNameLength>::npos))
539 {
540 g_contextDebugInfo.emplace(std::piecewise_construct, std::forward_as_tuple(szContextName), std::forward_as_tuple(contextPair.second.isActive));
541 }
542 }
543 }
544 }
545
546 //////////////////////////////////////////////////////////////////////////
547 void HandleUpdateDebugInfo(EDebugUpdateFilter const filter)
548 {
549 char const* const szDebugFilter = g_cvars.m_pDebugFilter->GetString();
550
551 if ((filter& EDebugUpdateFilter::FileCacheManager) != EDebugUpdateFilter::None)
552 {
553 g_fileCacheManager.UpdateDebugInfo(szDebugFilter);
554 }
555
556 if ((filter& EDebugUpdateFilter::Contexts) != EDebugUpdateFilter::None)
557 {
558 UpdateContextDebugInfo(szDebugFilter);
559 }
560 }
561 #endif // CRY_AUDIO_USE_DEBUG_CODE
562
563 //////////////////////////////////////////////////////////////////////////
564 void ReleaseGlobalData()
565 {
566 for (auto& triggerInstancePair : g_triggerInstances)
567 {
568 triggerInstancePair.second->Release();
569 }
570
571 g_pIObject = nullptr;
572 }
573
574 ///////////////////////////////////////////////////////////////////////////
575 void ReportStartedGlobalTriggerInstance(TriggerInstanceId const triggerInstanceId, ETriggerResult const result)
576 {
577 TriggerInstances::iterator const iter(g_triggerInstances.find(triggerInstanceId));
578
579 if (iter != g_triggerInstances.end())
580 {
581 iter->second->SetPendingToPlaying();
582 }
583 }
584
585 ///////////////////////////////////////////////////////////////////////////
586 void ReportFinishedTriggerInstance(TriggerInstanceId const triggerInstanceId, ETriggerResult const result)
587 {
588 TriggerInstances::iterator const iter(g_triggerInstances.find(triggerInstanceId));
589
590 if (iter != g_triggerInstances.end())
591 {
592 CTriggerInstance* const pTriggerInstance = iter->second;
593
594 if (result != ETriggerResult::Pending)
595 {
596 if (pTriggerInstance->IsPlayingInstanceFinished())
597 {
598 g_triggerInstanceIds.erase(std::remove(g_triggerInstanceIds.begin(), g_triggerInstanceIds.end(), triggerInstanceId), g_triggerInstanceIds.end());
599 pTriggerInstance->SendFinishedRequest();
600
601 g_triggerInstances.erase(iter);
602 delete pTriggerInstance;
603 }
604 }
605 else
606 {
607 if (pTriggerInstance->IsPendingInstanceFinished())
608 {
609 g_triggerInstanceIds.erase(std::remove(g_triggerInstanceIds.begin(), g_triggerInstanceIds.end(), triggerInstanceId), g_triggerInstanceIds.end());
610 pTriggerInstance->SendFinishedRequest();
611
612 g_triggerInstances.erase(iter);
613 delete pTriggerInstance;
614 }
615 }
616 }
617 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
618 else
619 {
620 Cry::Audio::Log(ELogType::Warning, "Unknown trigger instance id %u during %s", triggerInstanceId, __FUNCTION__);
621 }
622 #endif // CRY_AUDIO_USE_DEBUG_CODE
623 }
624
625 ///////////////////////////////////////////////////////////////////////////
626 void ReportTriggerInstanceCallback(TriggerInstanceId const triggerInstanceId, ESystemEvents const events)
627 {
628 TriggerInstances::iterator const iter(g_triggerInstances.find(triggerInstanceId));
629
630 if (iter != g_triggerInstances.end())
631 {
632 iter->second->SendCallbackRequest(events);
633 }
634 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
635 else
636 {
637 Cry::Audio::Log(ELogType::Warning, "Unknown trigger instance id %u during %s", triggerInstanceId, __FUNCTION__);
638 }
639 #endif // CRY_AUDIO_USE_DEBUG_CODE
640 }
641
642 ///////////////////////////////////////////////////////////////////////////
643 void UpdateGlobalData(float const deltaTime)
644 {
645 if (!g_triggerInstances.empty())
646 {
647 g_pIObject->Update(deltaTime);
648 }
649 }
650
651 //////////////////////////////////////////////////////////////////////////
652 void AllocateMemoryPools()
653 {
654 // Controls
655 CTrigger::CreateAllocator(g_poolSizes.triggers);
656 CParameter::CreateAllocator(g_poolSizes.parameters);
657 CSwitch::CreateAllocator(g_poolSizes.switches);
658 CSwitchState::CreateAllocator(g_poolSizes.states);
659 CEnvironment::CreateAllocator(g_poolSizes.environments);
660 CPreloadRequest::CreateAllocator(g_poolSizes.preloads);
661 CSetting::CreateAllocator(g_poolSizes.settings);
662
663 // Files
664 CFile::CreateAllocator(g_poolSizes.files);
665
666 // System requests
667 SSystemRequestData<ESystemRequestType::ExecuteTrigger>::CreateAllocator(g_systemExecuteTriggerPoolSize);
668 SSystemRequestData<ESystemRequestType::ExecuteTriggerEx>::CreateAllocator(g_systemExecuteTriggerExPoolSize);
669 SSystemRequestData<ESystemRequestType::ExecuteTriggerWithCallbacks>::CreateAllocator(g_systemExecuteTriggerWithCallbacksPoolSize);
670 SSystemRequestData<ESystemRequestType::StopTrigger>::CreateAllocator(g_systemStopTriggerPoolSize);
671 SSystemRequestData<ESystemRequestType::RegisterObject>::CreateAllocator(g_systemRegisterObjectPoolSize);
672 SSystemRequestData<ESystemRequestType::ReleaseObject>::CreateAllocator(g_systemReleaseObjectPoolSize);
673 SSystemRequestData<ESystemRequestType::SetParameter>::CreateAllocator(g_systemSetParameterPoolSize);
674 SSystemRequestData<ESystemRequestType::SetSwitchState>::CreateAllocator(g_systemSetSwitchStatePoolSize);
675
676 // Object requests
677 SObjectRequestData<EObjectRequestType::ExecuteTrigger>::CreateAllocator(g_objectExecuteTriggerPoolSize);
678 SObjectRequestData<EObjectRequestType::ExecuteTriggerWithCallbacks>::CreateAllocator(g_objectExecuteTriggerWithCallbacksPoolSize);
679 SObjectRequestData<EObjectRequestType::StopTrigger>::CreateAllocator(g_objectStopTriggerPoolSize);
680 SObjectRequestData<EObjectRequestType::SetTransformation>::CreateAllocator(g_objectSetTransformationPoolSize);
681 SObjectRequestData<EObjectRequestType::SetParameter>::CreateAllocator(g_objectSetParameterPoolSize);
682 SObjectRequestData<EObjectRequestType::SetSwitchState>::CreateAllocator(g_objectSetSwitchStatePoolSize);
683 SObjectRequestData<EObjectRequestType::SetCurrentEnvironments>::CreateAllocator(g_objectSetCurrentEnvironmentsPoolSize);
684 SObjectRequestData<EObjectRequestType::SetEnvironment>::CreateAllocator(g_objectSetEnvironmentPoolSize);
685 SObjectRequestData<EObjectRequestType::ProcessPhysicsRay>::CreateAllocator(g_objectProcessPhysicsRayPoolSize);
686
687 // Listener requests
688 SListenerRequestData<EListenerRequestType::SetTransformation>::CreateAllocator(g_listenerSetTransformationPoolSize);
689
690 // Callback requests
691 SCallbackRequestData<ECallbackRequestType::ReportStartedTriggerConnectionInstance>::CreateAllocator(g_callbackReportStartedTriggerConnectionInstancePoolSize);
692 SCallbackRequestData<ECallbackRequestType::ReportFinishedTriggerConnectionInstance>::CreateAllocator(g_callbackReportFinishedTriggerConnectionInstancePoolSize);
693 SCallbackRequestData<ECallbackRequestType::ReportFinishedTriggerInstance>::CreateAllocator(g_callbackReportFinishedTriggerInstancePoolSize);
694 SCallbackRequestData<ECallbackRequestType::ReportTriggerConnectionInstanceCallback>::CreateAllocator(g_callbackReportTriggerConnectionInstanceCallbackPoolSize);
695 SCallbackRequestData<ECallbackRequestType::SendTriggerInstanceCallback>::CreateAllocator(g_callbackSendTriggerInstanceCallbackPoolSize);
696 SCallbackRequestData<ECallbackRequestType::ReportPhysicalizedObject>::CreateAllocator(g_callbackReportPhysicalizedObjectPoolSize);
697 SCallbackRequestData<ECallbackRequestType::ReportVirtualizedObject>::CreateAllocator(g_callbackReportVirtualizedObjectPoolSize);
698 }
699
700 //////////////////////////////////////////////////////////////////////////
701 void FreeMemoryPools()
702 {
703 // Controls
704 CTrigger::FreeMemoryPool();
705 CParameter::FreeMemoryPool();
706 CSwitch::FreeMemoryPool();
707 CSwitchState::FreeMemoryPool();
708 CEnvironment::FreeMemoryPool();
709 CPreloadRequest::FreeMemoryPool();
710 CSetting::FreeMemoryPool();
711
712 // Files
713 CFile::FreeMemoryPool();
714
715 // System requests
716 SSystemRequestData<ESystemRequestType::ExecuteTrigger>::FreeMemoryPool();
717 SSystemRequestData<ESystemRequestType::ExecuteTriggerEx>::FreeMemoryPool();
718 SSystemRequestData<ESystemRequestType::ExecuteTriggerWithCallbacks>::FreeMemoryPool();
719 SSystemRequestData<ESystemRequestType::StopTrigger>::FreeMemoryPool();
720 SSystemRequestData<ESystemRequestType::RegisterObject>::FreeMemoryPool();
721 SSystemRequestData<ESystemRequestType::ReleaseObject>::FreeMemoryPool();
722 SSystemRequestData<ESystemRequestType::SetParameter>::FreeMemoryPool();
723 SSystemRequestData<ESystemRequestType::SetSwitchState>::FreeMemoryPool();
724
725 // Object requests
726 SObjectRequestData<EObjectRequestType::ExecuteTrigger>::FreeMemoryPool();
727 SObjectRequestData<EObjectRequestType::ExecuteTriggerWithCallbacks>::FreeMemoryPool();
728 SObjectRequestData<EObjectRequestType::StopTrigger>::FreeMemoryPool();
729 SObjectRequestData<EObjectRequestType::SetTransformation>::FreeMemoryPool();
730 SObjectRequestData<EObjectRequestType::SetParameter>::FreeMemoryPool();
731 SObjectRequestData<EObjectRequestType::SetSwitchState>::FreeMemoryPool();
732 SObjectRequestData<EObjectRequestType::SetCurrentEnvironments>::FreeMemoryPool();
733 SObjectRequestData<EObjectRequestType::SetEnvironment>::FreeMemoryPool();
734 SObjectRequestData<EObjectRequestType::ProcessPhysicsRay>::FreeMemoryPool();
735
736 // Listener requests
737 SListenerRequestData<EListenerRequestType::SetTransformation>::FreeMemoryPool();
738
739 // Callback requests
740 SCallbackRequestData<ECallbackRequestType::ReportStartedTriggerConnectionInstance>::FreeMemoryPool();
741 SCallbackRequestData<ECallbackRequestType::ReportFinishedTriggerConnectionInstance>::FreeMemoryPool();
742 SCallbackRequestData<ECallbackRequestType::ReportFinishedTriggerInstance>::FreeMemoryPool();
743 SCallbackRequestData<ECallbackRequestType::ReportTriggerConnectionInstanceCallback>::FreeMemoryPool();
744 SCallbackRequestData<ECallbackRequestType::SendTriggerInstanceCallback>::FreeMemoryPool();
745 SCallbackRequestData<ECallbackRequestType::ReportPhysicalizedObject>::FreeMemoryPool();
746 SCallbackRequestData<ECallbackRequestType::ReportVirtualizedObject>::FreeMemoryPool();
747 }
748
749 //////////////////////////////////////////////////////////////////////////
750 void UpdateActiveObjects(float const deltaTime)
751 {
752 #if defined(CRY_AUDIO_USE_DEBUG_CODE) && defined(CRY_AUDIO_USE_OCCLUSION)
753 CPropagationProcessor::s_totalAsyncPhysRays = 0;
754 CPropagationProcessor::s_totalSyncPhysRays = 0;
755 #endif // CRY_AUDIO_USE_DEBUG_CODE && CRY_AUDIO_USE_OCCLUSION
756
757 if (deltaTime > 0.0f)
758 {
759 UpdateGlobalData(deltaTime);
760
761 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
762 if (g_previewObject.IsActive())
763 {
764 g_previewObject.Update(deltaTime);
765 }
766 #endif // CRY_AUDIO_USE_DEBUG_CODE
767
768 auto iter = g_activeObjects.begin();
769 auto iterEnd = g_activeObjects.end();
770
771 while (iter != iterEnd)
772 {
773 CObject* const pObject = *iter;
774
775 if (pObject->IsActive())
776 {
777 pObject->Update(deltaTime);
778 }
779 else if (!pObject->HasPendingCallbacks())
780 {
781 pObject->RemoveFlag(EObjectFlags::Active);
782
783 if ((pObject->GetFlags() & EObjectFlags::InUse) == EObjectFlags::None)
784 {
785 pObject->Destruct();
786 }
787
788 if (iter != (iterEnd - 1))
789 {
790 (*iter) = g_activeObjects.back();
791 }
792
793 g_activeObjects.pop_back();
794 iter = g_activeObjects.begin();
795 iterEnd = g_activeObjects.end();
796 continue;
797 }
798
799 ++iter;
800 }
801 }
802 else
803 {
804 UpdateGlobalData(deltaTime);
805
806 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
807 if (g_previewObject.IsActive())
808 {
809 g_previewObject.Update(deltaTime);
810 }
811 #endif // CRY_AUDIO_USE_DEBUG_CODE
812
813 for (auto const pObject : g_activeObjects)
814 {
815 pObject->GetImplData()->Update(deltaTime);
816 }
817 }
818 }
819
820 //////////////////////////////////////////////////////////////////////////
821 CSystem::~CSystem()
822 {
823 CRY_ASSERT_MESSAGE(g_pIImpl == nullptr, "<Audio> The implementation must get destroyed before the audio system is destructed during %s", __FUNCTION__);
824 CRY_ASSERT_MESSAGE(g_activeObjects.empty(), "There are still active objects during %s", __FUNCTION__);
825
826 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
827 CRY_ASSERT_MESSAGE(g_constructedObjects.empty(), "There are still objects during %s", __FUNCTION__);
828 #endif // CRY_AUDIO_USE_DEBUG_CODE
829 }
830
831 //////////////////////////////////////////////////////////////////////////
832 void CSystem::AddRequestListener(void (*func)(SRequestInfo const* const), void* const pObjectToListenTo, ESystemEvents const eventMask)
833 {
834 SSystemRequestData<ESystemRequestType::AddRequestListener> const requestData(pObjectToListenTo, func, eventMask);
835 CRequest const request(&requestData, ERequestFlags::ExecuteBlocking, pObjectToListenTo); // This makes sure that the listener is notified.
836 PushRequest(request);
837 }
838
839 //////////////////////////////////////////////////////////////////////////
840 void CSystem::RemoveRequestListener(void (*func)(SRequestInfo const* const), void* const pObjectToListenTo)
841 {
842 SSystemRequestData<ESystemRequestType::RemoveRequestListener> const requestData(pObjectToListenTo, func);
843 CRequest const request(&requestData, ERequestFlags::ExecuteBlocking, pObjectToListenTo); // This makes sure that the listener is notified.
844 PushRequest(request);
845 }
846
847 //////////////////////////////////////////////////////////////////////////
848 void CSystem::ExternalUpdate()
849 {
850 CRY_PROFILE_SECTION(PROFILE_AUDIO, "Audio: External Update");
851
852 CRY_ASSERT(gEnv->mMainThreadId == CryGetCurrentThreadId());
853 CRequest request;
854
855 while (m_syncCallbacks.dequeue(request))
856 {
857 NotifyListener(request);
858
859 if (request.GetData()->requestType == ERequestType::ObjectRequest)
860 {
861 auto const pBase = static_cast<SObjectRequestDataBase const*>(request.GetData());
862 pBase->pObject->DecrementSyncCallbackCounter();
863 // No sync callback counting for default object, because it gets released on unloading of the audio system dll.
864 }
865 }
866
867 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
868 DrawDebug();
869 #endif // CRY_AUDIO_USE_DEBUG_CODE
870
871 m_accumulatedFrameTime += gEnv->pTimer->GetFrameTime();
872 ++m_externalThreadFrameId;
873
874 // If sleeping, wake up the audio thread to start processing requests again.
875 m_audioThreadWakeupEvent.Set();
876 }
877
878 //////////////////////////////////////////////////////////////////////////
879 void CSystem::PushRequest(CRequest const& request)
880 {
881 CRY_PROFILE_FUNCTION(PROFILE_AUDIO);
882
883 if ((g_systemStates& ESystemStates::ImplShuttingDown) == ESystemStates::None)
884 {
885 m_requestQueue.enqueue(request);
886
887 if ((request.flags & ERequestFlags::ExecuteBlocking) != ERequestFlags::None)
888 {
889 // If sleeping, wake up the audio thread to start processing requests again.
890 m_audioThreadWakeupEvent.Set();
891
892 m_mainEvent.Wait();
893 m_mainEvent.Reset();
894
895 if ((request.flags & ERequestFlags::CallbackOnExternalOrCallingThread) != ERequestFlags::None)
896 {
897 NotifyListener(m_syncRequest);
898 }
899 }
900 }
901 else
902 {
903 Log(ELogType::Warning, "Discarded PushRequest due to Audio System not allowing for new ones!");
904 }
905 }
906
907 //////////////////////////////////////////////////////////////////////////
908 void CSystem::OnSystemEvent(ESystemEvent event, UINT_PTR wparam, UINT_PTR lparam)
909 {
910 switch (event)
911 {
912 case ESYSTEM_EVENT_LEVEL_LOAD_START:
913 {
914 // This event is issued in Editor and Game mode.
915 string const contextName = PathUtil::GetFileName(reinterpret_cast<const char*>(wparam));
916
917 if (!contextName.empty() && (contextName.compareNoCase("Untitled") != 0))
918 {
919 g_currentLevelContextId = StringToId(contextName.c_str());
920
921 CryFixedStringT<MaxFilePathLength> contextPath(g_configPath);
922 contextPath += g_szContextsFolderName;
923 contextPath += "/";
924 contextPath += contextName;
925
926 SSystemRequestData<ESystemRequestType::ParseControlsData> const requestData1(contextPath.c_str(), contextName.c_str(), g_currentLevelContextId);
927 CRequest const request1(&requestData1);
928 PushRequest(request1);
929
930 SSystemRequestData<ESystemRequestType::ParsePreloadsData> const requestData2(contextPath.c_str(), g_currentLevelContextId);
931 CRequest const request2(&requestData2);
932 PushRequest(request2);
933
934 auto const preloadRequestId = static_cast<PreloadRequestId>(g_currentLevelContextId);
935 SSystemRequestData<ESystemRequestType::PreloadSingleRequest> const requestData3(preloadRequestId, true);
936 CRequest const request3(&requestData3);
937 PushRequest(request3);
938
939 SSystemRequestData<ESystemRequestType::AutoLoadSetting> const requestData4(g_currentLevelContextId);
940 CRequest const request4(&requestData4);
941 PushRequest(request4);
942
943 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
944 ResetRequestCount();
945 #endif // CRY_AUDIO_USE_DEBUG_CODE
946 }
947
948 break;
949 }
950 case ESYSTEM_EVENT_LEVEL_UNLOAD:
951 {
952 // This event is issued in Editor and Game mode.
953 #if defined(CRY_AUDIO_USE_OCCLUSION)
954 CPropagationProcessor::s_bCanIssueRWIs = false;
955 #endif // CRY_AUDIO_USE_OCCLUSION
956
957 SSystemRequestData<ESystemRequestType::ReleasePendingRays> const requestData1;
958 CRequest const request1(&requestData1);
959 PushRequest(request1);
960
961 SSystemRequestData<ESystemRequestType::UnloadAFCMDataByContext> const requestData2(g_currentLevelContextId);
962 CRequest const request2(&requestData2);
963 PushRequest(request2);
964
965 SSystemRequestData<ESystemRequestType::ClearControlsData> const requestData3(g_currentLevelContextId);
966 CRequest const request3(&requestData3);
967 PushRequest(request3);
968
969 SSystemRequestData<ESystemRequestType::ClearPreloadsData> const requestData4(g_currentLevelContextId);
970 CRequest const request4(&requestData4);
971 PushRequest(request4);
972
973 break;
974 }
975 #if defined(CRY_AUDIO_USE_OCCLUSION)
976 case ESYSTEM_EVENT_LEVEL_LOAD_END:
977 {
978 // This event is issued in Editor and Game mode.
979 CPropagationProcessor::s_bCanIssueRWIs = true;
980
981 break;
982 }
983 #endif // CRY_AUDIO_USE_OCCLUSION
984 case ESYSTEM_EVENT_CRYSYSTEM_INIT_DONE:
985 {
986 if (gEnv->pInput != nullptr)
987 {
988 gEnv->pInput->AddConsoleEventListener(this);
989 }
990
991 break;
992 }
993 case ESYSTEM_EVENT_FULL_SHUTDOWN: // Intentional fall-through.
994 case ESYSTEM_EVENT_FAST_SHUTDOWN:
995 {
996 if (gEnv->pInput != nullptr)
997 {
998 gEnv->pInput->RemoveConsoleEventListener(this);
999 }
1000
1001 break;
1002 }
1003 case ESYSTEM_EVENT_ACTIVATE:
1004 {
1005 // When Alt+Tabbing out of the application while it's in full-screen mode
1006 // ESYSTEM_EVENT_ACTIVATE is sent instead of ESYSTEM_EVENT_CHANGE_FOCUS.
1007 if (g_cvars.m_ignoreWindowFocus == 0)
1008 {
1009 // wparam != 0 is active, wparam == 0 is inactive
1010 // lparam != 0 is minimized, lparam == 0 is not minimized
1011 if (wparam == 0 || lparam != 0)
1012 {
1013 // lost focus
1014 ExecuteDefaultTrigger(EDefaultTriggerType::LoseFocus);
1015 }
1016 else
1017 {
1018 // got focus
1019 ExecuteDefaultTrigger(EDefaultTriggerType::GetFocus);
1020 }
1021 }
1022
1023 break;
1024 }
1025 case ESYSTEM_EVENT_CHANGE_FOCUS:
1026 {
1027 if (g_cvars.m_ignoreWindowFocus == 0)
1028 {
1029 // wparam != 0 is focused, wparam == 0 is not focused
1030 if (wparam == 0)
1031 {
1032 // lost focus
1033 ExecuteDefaultTrigger(EDefaultTriggerType::LoseFocus);
1034 }
1035 else
1036 {
1037 // got focus
1038 ExecuteDefaultTrigger(EDefaultTriggerType::GetFocus);
1039 }
1040 }
1041
1042 break;
1043 }
1044 case ESYSTEM_EVENT_AUDIO_MUTE:
1045 {
1046 ExecuteDefaultTrigger(EDefaultTriggerType::MuteAll);
1047
1048 break;
1049 }
1050 case ESYSTEM_EVENT_AUDIO_UNMUTE:
1051 {
1052 ExecuteDefaultTrigger(EDefaultTriggerType::UnmuteAll);
1053
1054 break;
1055 }
1056 case ESYSTEM_EVENT_AUDIO_PAUSE:
1057 {
1058 ExecuteDefaultTrigger(EDefaultTriggerType::PauseAll);
1059
1060 break;
1061 }
1062 case ESYSTEM_EVENT_AUDIO_RESUME:
1063 {
1064 ExecuteDefaultTrigger(EDefaultTriggerType::ResumeAll);
1065
1066 break;
1067 }
1068 case ESYSTEM_EVENT_AUDIO_LANGUAGE_CHANGED:
1069 {
1070 OnLanguageChanged();
1071
1072 break;
1073 }
1074 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1075 case ESYSTEM_EVENT_AUDIO_REFRESH:
1076 {
1077 SSystemRequestData<ESystemRequestType::RefreshSystem> const requestData;
1078 CRequest const request(&requestData, ERequestFlags::ExecuteBlocking);
1079 PushRequest(request);
1080
1081 break;
1082 }
1083 case ESYSTEM_EVENT_AUDIO_RELOAD_CONTROLS_DATA:
1084 {
1085 SSystemRequestData<ESystemRequestType::ReloadControlsData> const requestData;
1086 CRequest const request(&requestData);
1087 PushRequest(request);
1088
1089 break;
1090 }
1091 #endif // CRY_AUDIO_USE_DEBUG_CODE
1092 default:
1093 {
1094 break;
1095 }
1096 }
1097 }
1098
1099 //////////////////////////////////////////////////////////////////////////
1100 bool CSystem::OnInputEvent(SInputEvent const& event)
1101 {
1102 if (event.state == eIS_Changed && event.deviceType == eIDT_Gamepad)
1103 {
1104 if (event.keyId == eKI_SYS_ConnectDevice)
1105 {
1106 g_pIImpl->GamepadConnected(event.deviceUniqueID);
1107 }
1108 else if (event.keyId == eKI_SYS_DisconnectDevice)
1109 {
1110 g_pIImpl->GamepadDisconnected(event.deviceUniqueID);
1111 }
1112 }
1113
1114 // Do not consume event
1115 return false;
1116 }
1117
1118 //////////////////////////////////////////////////////////////////////////
1119 void CSystem::InternalUpdate()
1120 {
1121 CRY_PROFILE_SECTION(PROFILE_AUDIO, "Audio: Internal Update");
1122
1123 if (m_lastExternalThreadFrameId != m_externalThreadFrameId)
1124 {
1125 if (g_pIImpl != nullptr)
1126 {
1127 g_listenerManager.Update(m_accumulatedFrameTime);
1128 UpdateActiveObjects(m_accumulatedFrameTime);
1129 g_pIImpl->Update();
1130 }
1131
1132 ProcessRequests(m_requestQueue);
1133 m_lastExternalThreadFrameId = m_externalThreadFrameId;
1134 m_accumulatedFrameTime = 0.0f;
1135 m_didThreadWait = false;
1136 }
1137 else if (m_didThreadWait)
1138 {
1139 // Effectively no time has passed for the external thread as it didn't progress.
1140 // Consequently 0.0f is passed for deltaTime.
1141 if (g_pIImpl != nullptr)
1142 {
1143 g_listenerManager.Update(0.0f);
1144 UpdateActiveObjects(0.0f);
1145 g_pIImpl->Update();
1146 }
1147
1148 ProcessRequests(m_requestQueue);
1149 m_didThreadWait = false;
1150 }
1151 else
1152 {
1153 // If we're faster than the external thread let's wait to make room for other threads.
1154 CRY_PROFILE_SECTION_WAITING(PROFILE_AUDIO, "Wait - Audio Update");
1155
1156 // The external thread will wake the audio thread up effectively syncing it to itself.
1157 // If not however, the audio thread will execute at a minimum of roughly 30 fps.
1158 if (m_audioThreadWakeupEvent.Wait(30))
1159 {
1160 // Only reset if the event was signaled, not timed-out!
1161 m_audioThreadWakeupEvent.Reset();
1162 }
1163
1164 m_didThreadWait = true;
1165 }
1166 }
1167
1168 ///////////////////////////////////////////////////////////////////////////
1169 bool CSystem::Initialize()
1170 {
1171 if (!m_isInitialized)
1172 {
1173 g_cvars.RegisterVariables();
1174
1175 if (g_cvars.m_objectPoolSize < 1)
1176 {
1177 g_cvars.m_objectPoolSize = 1;
1178
1179 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1180 Cry::Audio::Log(ELogType::Warning, R"(Audio Object pool size must be at least 1. Forcing the cvar "s_AudioObjectPoolSize" to 1!)");
1181 #endif // CRY_AUDIO_USE_DEBUG_CODE
1182 }
1183
1184 CObject::CreateAllocator(static_cast<uint16>(g_cvars.m_objectPoolSize));
1185
1186 #if defined(CRY_AUDIO_USE_OCCLUSION)
1187 SOcclusionInfo::CreateAllocator(static_cast<uint16>(g_cvars.m_objectPoolSize));
1188 #endif // CRY_AUDIO_USE_OCCLUSION
1189
1190 if (g_cvars.m_triggerInstancePoolSize < 1)
1191 {
1192 g_cvars.m_triggerInstancePoolSize = 1;
1193
1194 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1195 Cry::Audio::Log(ELogType::Warning, R"(Trigger instance pool size must be at least 1. Forcing the cvar "s_TriggerInstancePoolSize" to 1!)");
1196 #endif // CRY_AUDIO_USE_DEBUG_CODE
1197 }
1198
1199 CTriggerInstance::CreateAllocator(static_cast<uint16>(g_cvars.m_triggerInstancePoolSize));
1200
1201 #if defined(CRY_AUDIO_USE_OCCLUSION)
1202 // Add the callback for the obstruction calculation.
1203 gEnv->pPhysicalWorld->AddEventClient(
1204 EventPhysRWIResult::id,
1205 &CPropagationProcessor::OnObstructionTest,
1206 1);
1207
1208 CPropagationProcessor::UpdateOcclusionRayFlags();
1209 CPropagationProcessor::UpdateOcclusionPlanes();
1210 #endif // CRY_AUDIO_USE_OCCLUSION
1211
1212 m_objectPoolSize = static_cast<uint16>(g_cvars.m_objectPoolSize);
1213
1214 g_activeObjects.reserve(static_cast<size_t>(m_objectPoolSize));
1215
1216 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1217 g_constructedObjects.reserve(static_cast<size_t>(m_objectPoolSize));
1218
1219 g_contextInfo.emplace(
1220 std::piecewise_construct,
1221 std::forward_as_tuple(g_szGlobalContextName),
1222 std::forward_as_tuple(SContextInfo(GlobalContextId, true, true)));
1223 #endif // CRY_AUDIO_USE_DEBUG_CODE
1224
1225 g_listenerManager.Initialize();
1226 g_fileCacheManager.Initialize();
1227
1228 CRY_ASSERT_MESSAGE(!m_mainThread.IsActive(), "AudioSystem thread active before initialization during %s", __FUNCTION__);
1229 m_mainThread.Activate();
1230 AddRequestListener(&CSystem::OnCallback, nullptr, ESystemEvents::TriggerExecuted | ESystemEvents::TriggerFinished);
1231 m_isInitialized = true;
1232 }
1233 else
1234 {
1235 CRY_ASSERT_MESSAGE(false, "AudioSystem has already been initialized during %s", __FUNCTION__);
1236 }
1237
1238 return m_isInitialized;
1239 }
1240
1241 ///////////////////////////////////////////////////////////////////////////
1242 void CSystem::Release()
1243 {
1244 if (m_isInitialized)
1245 {
1246 RemoveRequestListener(&CSystem::OnCallback, nullptr);
1247
1248 SSystemRequestData<ESystemRequestType::ReleaseImpl> const requestData;
1249 CRequest const request(&requestData, ERequestFlags::ExecuteBlocking);
1250 PushRequest(request);
1251
1252 m_mainThread.Deactivate();
1253
1254 #if defined(CRY_AUDIO_USE_OCCLUSION)
1255 if (gEnv->pPhysicalWorld != nullptr)
1256 {
1257 // remove the callback for the obstruction calculation
1258 gEnv->pPhysicalWorld->RemoveEventClient(
1259 EventPhysRWIResult::id,
1260 &CPropagationProcessor::OnObstructionTest,
1261 1);
1262 }
1263 #endif // CRY_AUDIO_USE_OCCLUSION
1264
1265 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1266 for (auto const pObject : g_constructedObjects)
1267 {
1268 CRY_ASSERT_MESSAGE(pObject->GetImplData() == nullptr, "An object cannot have valid impl data during %s", __FUNCTION__);
1269 delete pObject;
1270 }
1271
1272 g_constructedObjects.clear();
1273 #endif // CRY_AUDIO_USE_DEBUG_CODE
1274
1275 g_listenerManager.Terminate();
1276 g_cvars.UnregisterVariables();
1277
1278 CObject::FreeMemoryPool();
1279 CTriggerInstance::FreeMemoryPool();
1280
1281 #if defined(CRY_AUDIO_USE_OCCLUSION)
1282 SOcclusionInfo::FreeMemoryPool();
1283 #endif // CRY_AUDIO_USE_OCCLUSION
1284
1285 m_isInitialized = false;
1286 }
1287 else
1288 {
1289 CRY_ASSERT_MESSAGE(false, "AudioSystem has already been released or was never properly initialized during %s", __FUNCTION__);
1290 }
1291 }
1292
1293 //////////////////////////////////////////////////////////////////////////
1294 void CSystem::SetImpl(Impl::IImpl* const pIImpl, SRequestUserData const& userData /*= SAudioRequestUserData::GetEmptyObject()*/)
1295 {
1296 SSystemRequestData<ESystemRequestType::SetImpl> const requestData(pIImpl);
1297 CRequest const request(&requestData, userData);
1298 PushRequest(request);
1299 }
1300
1301 //////////////////////////////////////////////////////////////////////////
1302 void CSystem::ExecuteTriggerEx(SExecuteTriggerData const& triggerData, SRequestUserData const& userData /* = SAudioRequestUserData::GetEmptyObject() */)
1303 {
1304 SSystemRequestData<ESystemRequestType::ExecuteTriggerEx> const requestData(triggerData);
1305 CRequest const request(&requestData, userData);
1306 PushRequest(request);
1307 }
1308
1309 //////////////////////////////////////////////////////////////////////////
1310 void CSystem::ExecuteDefaultTrigger(EDefaultTriggerType const type, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1311 {
1312 SSystemRequestData<ESystemRequestType::ExecuteDefaultTrigger> const requestData(type);
1313 CRequest const request(&requestData, userData);
1314 PushRequest(request);
1315 }
1316
1317 //////////////////////////////////////////////////////////////////////////
1318 void CSystem::SetParameter(ControlId const parameterId, float const value, SRequestUserData const& userData /* = SAudioRequestUserData::GetEmptyObject() */)
1319 {
1320 SSystemRequestData<ESystemRequestType::SetParameter> const requestData(parameterId, value);
1321 CRequest const request(&requestData, userData);
1322 PushRequest(request);
1323 }
1324
1325 //////////////////////////////////////////////////////////////////////////
1326 void CSystem::SetParameterGlobally(ControlId const parameterId, float const value, SRequestUserData const& userData /* = SAudioRequestUserData::GetEmptyObject() */)
1327 {
1328 SSystemRequestData<ESystemRequestType::SetParameterGlobally> const requestData(parameterId, value);
1329 CRequest const request(&requestData, userData);
1330 PushRequest(request);
1331 }
1332
1333 //////////////////////////////////////////////////////////////////////////
1334 void CSystem::SetSwitchState(ControlId const switchId, SwitchStateId const switchStateId, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1335 {
1336 SSystemRequestData<ESystemRequestType::SetSwitchState> const requestData(switchId, switchStateId);
1337 CRequest const request(&requestData, userData);
1338 PushRequest(request);
1339 }
1340
1341 //////////////////////////////////////////////////////////////////////////
1342 void CSystem::SetSwitchStateGlobally(ControlId const switchId, SwitchStateId const switchStateId, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1343 {
1344 SSystemRequestData<ESystemRequestType::SetSwitchStateGlobally> const requestData(switchId, switchStateId);
1345 CRequest const request(&requestData, userData);
1346 PushRequest(request);
1347 }
1348
1349 //////////////////////////////////////////////////////////////////////////
1350 void CSystem::ExecuteTrigger(ControlId const triggerId, SRequestUserData const& userData /* = SAudioRequestUserData::GetEmptyObject() */)
1351 {
1352 SSystemRequestData<ESystemRequestType::ExecuteTrigger> const requestData(triggerId);
1353 CRequest const request(&requestData, userData);
1354 PushRequest(request);
1355 }
1356
1357 //////////////////////////////////////////////////////////////////////////
1358 void CSystem::ExecuteTriggerWithCallbacks(STriggerCallbackData const& callbackData, SRequestUserData const& userData /* = SRequestUserData::GetEmptyObject() */)
1359 {
1360 SSystemRequestData<ESystemRequestType::ExecuteTriggerWithCallbacks> const requestData(callbackData);
1361 CRequest const request(&requestData, userData);
1362 PushRequest(request);
1363 }
1364
1365 //////////////////////////////////////////////////////////////////////////
1366 void CSystem::StopTrigger(ControlId const triggerId /* = CryAudio::InvalidControlId */, SRequestUserData const& userData /* = SAudioRequestUserData::GetEmptyObject() */)
1367 {
1368 if (triggerId != InvalidControlId)
1369 {
1370 SSystemRequestData<ESystemRequestType::StopTrigger> const requestData(triggerId);
1371 CRequest const request(&requestData, userData);
1372 PushRequest(request);
1373 }
1374 else
1375 {
1376 SSystemRequestData<ESystemRequestType::StopAllTriggers> const requestData;
1377 CRequest const request(&requestData, userData);
1378 PushRequest(request);
1379 }
1380 }
1381
1382 //////////////////////////////////////////////////////////////////////////
1383 void CSystem::ExecutePreviewTrigger(ControlId const triggerId)
1384 {
1385 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1386 switch (triggerId)
1387 {
1388 case g_loseFocusTriggerId:
1389 {
1390 SSystemRequestData<ESystemRequestType::ExecuteDefaultTrigger> const requestData(EDefaultTriggerType::LoseFocus);
1391 CRequest const request(&requestData);
1392 PushRequest(request);
1393
1394 break;
1395 }
1396 case g_getFocusTriggerId:
1397 {
1398 SSystemRequestData<ESystemRequestType::ExecuteDefaultTrigger> const requestData(EDefaultTriggerType::GetFocus);
1399 CRequest const request(&requestData);
1400 PushRequest(request);
1401
1402 break;
1403 }
1404 case g_muteAllTriggerId:
1405 {
1406 SSystemRequestData<ESystemRequestType::ExecuteDefaultTrigger> const requestData(EDefaultTriggerType::MuteAll);
1407 CRequest const request(&requestData);
1408 PushRequest(request);
1409
1410 break;
1411 }
1412 case g_unmuteAllTriggerId:
1413 {
1414 SSystemRequestData<ESystemRequestType::ExecuteDefaultTrigger> const requestData(EDefaultTriggerType::UnmuteAll);
1415 CRequest const request(&requestData);
1416 PushRequest(request);
1417
1418 break;
1419 }
1420 case g_pauseAllTriggerId:
1421 {
1422 SSystemRequestData<ESystemRequestType::ExecuteDefaultTrigger> const requestData(EDefaultTriggerType::PauseAll);
1423 CRequest const request(&requestData);
1424 PushRequest(request);
1425
1426 break;
1427 }
1428 case g_resumeAllTriggerId:
1429 {
1430 SSystemRequestData<ESystemRequestType::ExecuteDefaultTrigger> const requestData(EDefaultTriggerType::ResumeAll);
1431 CRequest const request(&requestData);
1432 PushRequest(request);
1433
1434 break;
1435 }
1436 default:
1437 {
1438 SSystemRequestData<ESystemRequestType::ExecutePreviewTrigger> const requestData(triggerId);
1439 CRequest const request(&requestData);
1440 PushRequest(request);
1441
1442 break;
1443 }
1444 }
1445 #endif // CRY_AUDIO_USE_DEBUG_CODE
1446 }
1447
1448 //////////////////////////////////////////////////////////////////////////
1449 void CSystem::ExecutePreviewTriggerEx(Impl::ITriggerInfo const& triggerInfo)
1450 {
1451 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1452 SSystemRequestData<ESystemRequestType::ExecutePreviewTriggerEx> const requestData(triggerInfo);
1453 CRequest const request(&requestData);
1454 PushRequest(request);
1455 #endif // CRY_AUDIO_USE_DEBUG_CODE
1456 }
1457
1458 //////////////////////////////////////////////////////////////////////////
1459 void CSystem::ExecutePreviewTriggerEx(XmlNodeRef const& node)
1460 {
1461 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1462 SSystemRequestData<ESystemRequestType::ExecutePreviewTriggerExNode> const requestData(node);
1463 CRequest const request(&requestData);
1464 PushRequest(request);
1465 #endif // CRY_AUDIO_USE_DEBUG_CODE
1466 }
1467
1468 //////////////////////////////////////////////////////////////////////////
1469 void CSystem::StopPreviewTrigger()
1470 {
1471 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1472 SSystemRequestData<ESystemRequestType::StopPreviewTrigger> const requestData;
1473 CRequest const request(&requestData);
1474 PushRequest(request);
1475 #endif // CRY_AUDIO_USE_DEBUG_CODE
1476 }
1477
1478 //////////////////////////////////////////////////////////////////////////
1479 void CSystem::RefreshObject(Impl::IObject* const pIObject)
1480 {
1481 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1482 SSystemRequestData<ESystemRequestType::RefreshObject> const requestData(pIObject);
1483 CRequest const request(&requestData);
1484 PushRequest(request);
1485 #endif // CRY_AUDIO_USE_DEBUG_CODE
1486 }
1487
1488 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1489 //////////////////////////////////////////////////////////////////////////
1490 void CSystem::ResetRequestCount()
1491 {
1492 SSystemRequestData<ESystemRequestType::ResetRequestCount> const requestData;
1493 CRequest const request(&requestData);
1494 PushRequest(request);
1495 }
1496 #endif // CRY_AUDIO_USE_DEBUG_CODE
1497
1498 //////////////////////////////////////////////////////////////////////////
1499 void CSystem::ReportStartedTriggerConnectionInstance(TriggerInstanceId const triggerInstanceId, ETriggerResult const result, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1500 {
1501 SCallbackRequestData<ECallbackRequestType::ReportStartedTriggerConnectionInstance> const requestData(triggerInstanceId, result);
1502 CRequest const request(&requestData, userData);
1503 PushRequest(request);
1504 }
1505
1506 //////////////////////////////////////////////////////////////////////////
1507 void CSystem::ReportFinishedTriggerConnectionInstance(TriggerInstanceId const triggerInstanceId, ETriggerResult const result, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1508 {
1509 SCallbackRequestData<ECallbackRequestType::ReportFinishedTriggerConnectionInstance> const requestData(triggerInstanceId, result);
1510 CRequest const request(&requestData, userData);
1511 PushRequest(request);
1512 }
1513
1514 //////////////////////////////////////////////////////////////////////////
1515 void CSystem::ReportTriggerConnectionInstanceCallback(TriggerInstanceId const triggerInstanceId, ESystemEvents const systemEvent, SRequestUserData const& userData /* = SRequestUserData::GetEmptyObject() */)
1516 {
1517 SCallbackRequestData<ECallbackRequestType::ReportTriggerConnectionInstanceCallback> const requestData(triggerInstanceId, systemEvent);
1518 CRequest const request(&requestData, userData);
1519 PushRequest(request);
1520 }
1521
1522 //////////////////////////////////////////////////////////////////////////
1523 void CSystem::ReportPhysicalizedObject(Impl::IObject* const pIObject, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1524 {
1525 SCallbackRequestData<ECallbackRequestType::ReportPhysicalizedObject> const requestData(pIObject);
1526 CRequest const request(&requestData, userData);
1527 PushRequest(request);
1528 }
1529
1530 //////////////////////////////////////////////////////////////////////////
1531 void CSystem::ReportVirtualizedObject(Impl::IObject* const pIObject, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1532 {
1533 SCallbackRequestData<ECallbackRequestType::ReportVirtualizedObject> const requestData(pIObject);
1534 CRequest const request(&requestData, userData);
1535 PushRequest(request);
1536 }
1537
1538 //////////////////////////////////////////////////////////////////////////
1539 void CSystem::StopAllSounds(SRequestUserData const& userData /* = SAudioRequestUserData::GetEmptyObject() */)
1540 {
1541 SSystemRequestData<ESystemRequestType::StopAllSounds> const requestData;
1542 CRequest const request(&requestData, userData);
1543 PushRequest(request);
1544 }
1545
1546 //////////////////////////////////////////////////////////////////////////
1547 void CSystem::ParseControlsData(
1548 char const* const szFolderPath,
1549 char const* const szContextName,
1550 ContextId const contextId,
1551 SRequestUserData const& userData /* = SAudioRequestUserData::GetEmptyObject() */)
1552 {
1553 SSystemRequestData<ESystemRequestType::ParseControlsData> const requestData(szFolderPath, szContextName, contextId);
1554 CRequest const request(&requestData, userData);
1555 PushRequest(request);
1556 }
1557
1558 //////////////////////////////////////////////////////////////////////////
1559 void CSystem::ParsePreloadsData(
1560 char const* const szFolderPath,
1561 ContextId const contextId,
1562 SRequestUserData const& userData /* = SAudioRequestUserData::GetEmptyObject() */)
1563 {
1564 SSystemRequestData<ESystemRequestType::ParsePreloadsData> const requestData(szFolderPath, contextId);
1565 CRequest const request(&requestData, userData);
1566 PushRequest(request);
1567 }
1568
1569 //////////////////////////////////////////////////////////////////////////
1570 void CSystem::PreloadSingleRequest(PreloadRequestId const id, bool const bAutoLoadOnly, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1571 {
1572 SSystemRequestData<ESystemRequestType::PreloadSingleRequest> const requestData(id, bAutoLoadOnly);
1573 CRequest const request(&requestData, userData);
1574 PushRequest(request);
1575 }
1576
1577 //////////////////////////////////////////////////////////////////////////
1578 void CSystem::UnloadSingleRequest(PreloadRequestId const id, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1579 {
1580 SSystemRequestData<ESystemRequestType::UnloadSingleRequest> const requestData(id);
1581 CRequest const request(&requestData, userData);
1582 PushRequest(request);
1583 }
1584
1585 //////////////////////////////////////////////////////////////////////////
1586 void CSystem::ActivateContext(ContextId const contextId)
1587 {
1588 if ((contextId != InvalidContextId) && (contextId != GlobalContextId))
1589 {
1590 SSystemRequestData<ESystemRequestType::ActivateContext> const requestData(contextId);
1591 CRequest const request(&requestData);
1592 PushRequest(request);
1593 }
1594 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1595 else
1596 {
1597 if (contextId == InvalidContextId)
1598 {
1599 Cry::Audio::Log(ELogType::Warning, "Invalid context id passed in %s", __FUNCTION__);
1600 }
1601 else
1602 {
1603 Cry::Audio::Log(ELogType::Warning, "The global context cannot get activated manually.");
1604 }
1605 }
1606 #endif // CRY_AUDIO_USE_DEBUG_CODE
1607 }
1608
1609 //////////////////////////////////////////////////////////////////////////
1610 void CSystem::DeactivateContext(ContextId const contextId)
1611 {
1612 if ((contextId != InvalidContextId) && (contextId != GlobalContextId))
1613 {
1614 SSystemRequestData<ESystemRequestType::DeactivateContext> const requestData(contextId);
1615 CRequest const request(&requestData);
1616 PushRequest(request);
1617 }
1618 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1619 else
1620 {
1621 if (contextId == InvalidContextId)
1622 {
1623 Cry::Audio::Log(ELogType::Warning, "Invalid context id passed in %s", __FUNCTION__);
1624 }
1625 else
1626 {
1627 Cry::Audio::Log(ELogType::Warning, "The global context cannot get deactivated manually.");
1628 }
1629 }
1630 #endif // CRY_AUDIO_USE_DEBUG_CODE
1631 }
1632
1633 //////////////////////////////////////////////////////////////////////////
1634 void CSystem::AutoLoadSetting(ContextId const contextId, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1635 {
1636 SSystemRequestData<ESystemRequestType::AutoLoadSetting> const requestData(contextId);
1637 CRequest const request(&requestData, userData);
1638 PushRequest(request);
1639 }
1640
1641 //////////////////////////////////////////////////////////////////////////
1642 void CSystem::LoadSetting(ControlId const id, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1643 {
1644 SSystemRequestData<ESystemRequestType::LoadSetting> const requestData(id);
1645 CRequest const request(&requestData, userData);
1646 PushRequest(request);
1647 }
1648
1649 //////////////////////////////////////////////////////////////////////////
1650 void CSystem::UnloadSetting(ControlId const id, SRequestUserData const& userData /*= SRequestUserData::GetEmptyObject()*/)
1651 {
1652 SSystemRequestData<ESystemRequestType::UnloadSetting> const requestData(id);
1653 CRequest const request(&requestData, userData);
1654 PushRequest(request);
1655 }
1656
1657 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1658 //////////////////////////////////////////////////////////////////////////
1659 void CSystem::RetriggerControls(SRequestUserData const& userData /* = SAudioRequestUserData::GetEmptyObject() */)
1660 {
1661 SSystemRequestData<ESystemRequestType::RetriggerControls> const requestData;
1662 CRequest const request(&requestData, userData);
1663 PushRequest(request);
1664 }
1665 #endif // CRY_AUDIO_USE_DEBUG_CODE
1666
1667 ///////////////////////////////////////////////////////////////////////////
1668 char const* CSystem::GetConfigPath() const
1669 {
1670 return g_configPath.c_str();
1671 }
1672
1673 ///////////////////////////////////////////////////////////////////////////
1674 CryAudio::IListener* CSystem::CreateListener(CTransformation const& transformation, char const* const szName)
1675 {
1676 CListener* pListener = nullptr;
1677 SSystemRequestData<ESystemRequestType::RegisterListener> const requestData(&pListener, transformation, szName);
1678 CRequest const request(&requestData, ERequestFlags::ExecuteBlocking);
1679 PushRequest(request);
1680
1681 return static_cast<CryAudio::IListener*>(pListener);
1682 }
1683
1684 ///////////////////////////////////////////////////////////////////////////
1685 void CSystem::ReleaseListener(CryAudio::IListener* const pIListener)
1686 {
1687 if (static_cast<CListener*>(pIListener)->IsUserCreated())
1688 {
1689 SSystemRequestData<ESystemRequestType::ReleaseListener> const requestData(static_cast<CListener*>(pIListener));
1690 CRequest const request(&requestData);
1691 PushRequest(request);
1692 }
1693 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1694 else
1695 {
1696 Cry::Audio::Log(ELogType::Error, "Non-user-created listener cannot get released during %s", __FUNCTION__);
1697 }
1698 #endif // CRY_AUDIO_USE_DEBUG_CODE
1699 }
1700
1701 //////////////////////////////////////////////////////////////////////////
1702 IListener* CSystem::GetListener(ListenerId const id /*= DefaultListenerId*/)
1703 {
1704 CListener* pListener = &g_defaultListener;
1705
1706 if ((id != DefaultListenerId) && (id != InvalidListenerId))
1707 {
1708 SSystemRequestData<ESystemRequestType::GetListener> const requestData(&pListener, id);
1709 CRequest const request(&requestData, ERequestFlags::ExecuteBlocking);
1710 PushRequest(request);
1711 }
1712
1713 return static_cast<CryAudio::IListener*>(pListener);
1714 }
1715
1716 //////////////////////////////////////////////////////////////////////////
1717 CryAudio::IObject* CSystem::CreateObject(SCreateObjectData const& objectData /*= SCreateObjectData::GetEmptyObject()*/)
1718 {
1719 CObject* pObject = nullptr;
1720 SSystemRequestData<ESystemRequestType::RegisterObject> const requestData(&pObject, objectData);
1721 CRequest const request(&requestData, ERequestFlags::ExecuteBlocking);
1722 PushRequest(request);
1723
1724 return static_cast<CryAudio::IObject*>(pObject);
1725 }
1726
1727 //////////////////////////////////////////////////////////////////////////
1728 void CSystem::ReleaseObject(CryAudio::IObject* const pIObject)
1729 {
1730 CRY_ASSERT_MESSAGE(pIObject != nullptr, "pIObject is nullptr during %s", __FUNCTION__);
1731 SSystemRequestData<ESystemRequestType::ReleaseObject> const requestData(static_cast<CObject*>(pIObject));
1732 CRequest const request(&requestData);
1733 PushRequest(request);
1734 }
1735
1736 //////////////////////////////////////////////////////////////////////////
1737 void CSystem::GetTriggerData(ControlId const triggerId, STriggerData& triggerData)
1738 {
1739 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1740 CTrigger const* const pTrigger = stl::find_in_map(g_triggerLookup, triggerId, nullptr);
1741
1742 if (pTrigger != nullptr)
1743 {
1744 triggerData.radius = pTrigger->GetRadius();
1745 }
1746 #endif // CRY_AUDIO_USE_DEBUG_CODE
1747 }
1748
1749 //////////////////////////////////////////////////////////////////////////
1750 void CSystem::ReleaseImpl()
1751 {
1752 // Reject new requests during shutdown.
1753 g_systemStates |= ESystemStates::ImplShuttingDown;
1754
1755 g_pIImpl->OnBeforeRelease();
1756
1757 // Release middleware specific data before its shutdown.
1758 g_listenerManager.ReleaseImplData();
1759
1760 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1761 // Don't delete objects here as we need them to survive a middleware switch!
1762 for (auto const pObject : g_constructedObjects)
1763 {
1764 g_pIImpl->DestructObject(pObject->GetImplData());
1765 pObject->Release();
1766 }
1767 #endif // CRY_AUDIO_USE_DEBUG_CODE
1768
1769 g_pIImpl->DestructObject(g_pIObject);
1770 ReleaseGlobalData();
1771
1772 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1773 g_pIImpl->DestructObject(g_previewObject.GetImplData());
1774 g_previewObject.Release();
1775 ResetRequestCount();
1776 #endif // CRY_AUDIO_USE_DEBUG_CODE
1777
1778 g_xmlProcessor.ClearPreloadsData(GlobalContextId, true);
1779 g_xmlProcessor.ClearControlsData(GlobalContextId, true);
1780
1781 ReportContextDeactivated(GlobalContextId);
1782
1783 g_pIImpl->ShutDown();
1784 g_pIImpl->Release();
1785 g_pIImpl = nullptr;
1786
1787 FreeMemoryPools();
1788
1789 g_systemStates &= ~ESystemStates::ImplShuttingDown;
1790 }
1791
1792 //////////////////////////////////////////////////////////////////////////
1793 void CSystem::OnLanguageChanged()
1794 {
1795 SSystemRequestData<ESystemRequestType::ChangeLanguage> const requestData;
1796 CRequest const request(&requestData);
1797 PushRequest(request);
1798 }
1799
1800 //////////////////////////////////////////////////////////////////////////
1801 void CSystem::Log(ELogType const type, char const* const szFormat, ...)
1802 {
1803 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1804 if (szFormat != nullptr && szFormat[0] != '\0' && gEnv->pLog->GetVerbosityLevel() != -1)
1805 {
1806 CRY_PROFILE_SECTION(PROFILE_AUDIO, "CSystem::Log");
1807
1808 char buffer[256];
1809 va_list ArgList;
1810 va_start(ArgList, szFormat);
1811 cry_vsprintf(buffer, szFormat, ArgList);
1812 va_end(ArgList);
1813
1814 auto const loggingOptions = static_cast<ELoggingOptions>(g_cvars.m_loggingOptions);
1815
1816 switch (type)
1817 {
1818 case ELogType::Warning:
1819 {
1820 if ((loggingOptions& ELoggingOptions::Warnings) != ELoggingOptions::None)
1821 {
1822 gEnv->pSystem->Warning(VALIDATOR_MODULE_AUDIO, VALIDATOR_WARNING, VALIDATOR_FLAG_AUDIO, nullptr, "<Audio>: %s", buffer);
1823 }
1824
1825 break;
1826 }
1827 case ELogType::Error:
1828 {
1829 if ((loggingOptions& ELoggingOptions::Errors) != ELoggingOptions::None)
1830 {
1831 gEnv->pSystem->Warning(VALIDATOR_MODULE_AUDIO, VALIDATOR_ERROR, VALIDATOR_FLAG_AUDIO, nullptr, "<Audio>: %s", buffer);
1832 }
1833
1834 break;
1835 }
1836 case ELogType::Comment:
1837 {
1838 if ((gEnv->pLog != nullptr) && (gEnv->pLog->GetVerbosityLevel() >= 4) && ((loggingOptions& ELoggingOptions::Comments) != ELoggingOptions::None))
1839 {
1840 CryLogAlways("<Audio>: %s", buffer);
1841 }
1842
1843 break;
1844 }
1845 case ELogType::Always:
1846 {
1847 CryLogAlways("<Audio>: %s", buffer);
1848
1849 break;
1850 }
1851 default:
1852 {
1853 CRY_ASSERT(false);
1854
1855 break;
1856 }
1857 }
1858 }
1859 #endif // CRY_AUDIO_USE_DEBUG_CODE
1860 }
1861
1862 //////////////////////////////////////////////////////////////////////////
1863 void CSystem::ProcessRequests(Requests& requestQueue)
1864 {
1865 CRequest request;
1866
1867 while (requestQueue.dequeue(request))
1868 {
1869 if (request.status == ERequestStatus::None)
1870 {
1871 request.status = ERequestStatus::Pending;
1872 ProcessRequest(request);
1873 }
1874 else
1875 {
1876 // TODO: handle pending requests!
1877 }
1878
1879 if (request.status != ERequestStatus::Pending)
1880 {
1881 if ((request.flags & ERequestFlags::CallbackOnAudioThread) != ERequestFlags::None)
1882 {
1883 NotifyListener(request);
1884
1885 if ((request.flags & ERequestFlags::ExecuteBlocking) != ERequestFlags::None)
1886 {
1887 m_mainEvent.Set();
1888 }
1889 }
1890 else if ((request.flags & ERequestFlags::CallbackOnExternalOrCallingThread) != ERequestFlags::None)
1891 {
1892 if ((request.flags & ERequestFlags::ExecuteBlocking) != ERequestFlags::None)
1893 {
1894 m_syncRequest = request;
1895 m_mainEvent.Set();
1896 }
1897 else
1898 {
1899 if (request.GetData()->requestType == ERequestType::ObjectRequest)
1900 {
1901 auto const pBase = static_cast<SObjectRequestDataBase const*>(request.GetData());
1902 pBase->pObject->IncrementSyncCallbackCounter();
1903 // No sync callback counting for default object, because it gets released on unloading of the audio system dll.
1904 }
1905
1906 m_syncCallbacks.enqueue(request);
1907 }
1908 }
1909 else if ((request.flags & ERequestFlags::ExecuteBlocking) != ERequestFlags::None)
1910 {
1911 m_mainEvent.Set();
1912 }
1913 }
1914 }
1915
1916 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1917 SetRequestCountPeak();
1918 #endif // CRY_AUDIO_USE_DEBUG_CODE
1919 }
1920
1921 //////////////////////////////////////////////////////////////////////////
1922 void CSystem::ProcessRequest(CRequest& request)
1923 {
1924 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
1925 CountRequestPerUpdate(request);
1926 #endif // CRY_AUDIO_USE_DEBUG_CODE
1927
1928 ERequestStatus result = ERequestStatus::None;
1929
1930 if (request.GetData())
1931 {
1932 switch (request.GetData()->requestType)
1933 {
1934 case ERequestType::ObjectRequest:
1935 {
1936 result = ProcessObjectRequest(request);
1937
1938 break;
1939 }
1940 case ERequestType::ListenerRequest:
1941 {
1942 result = ProcessListenerRequest(request.GetData());
1943
1944 break;
1945 }
1946 case ERequestType::CallbackRequest:
1947 {
1948 result = ProcessCallbackRequest(request);
1949
1950 break;
1951 }
1952 case ERequestType::SystemRequest:
1953 {
1954 result = ProcessSystemRequest(request);
1955
1956 break;
1957 }
1958 default:
1959 {
1960 CRY_ASSERT_MESSAGE(false, "Unknown request type: %u during %s", request.GetData()->requestType, __FUNCTION__);
1961
1962 break;
1963 }
1964 }
1965 }
1966
1967 request.status = result;
1968 }
1969
1970 //////////////////////////////////////////////////////////////////////////
1971 ERequestStatus CSystem::ProcessSystemRequest(CRequest const& request)
1972 {
1973 ERequestStatus result = ERequestStatus::Failure;
1974 auto const pBase = static_cast<SSystemRequestDataBase const*>(request.GetData());
1975
1976 switch (pBase->systemRequestType)
1977 {
1978 case ESystemRequestType::AddRequestListener:
1979 {
1980 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::AddRequestListener> const*>(request.GetData());
1981 g_eventListenerManager.AddRequestListener(pRequestData);
1982 result = ERequestStatus::Success;
1983
1984 break;
1985 }
1986 case ESystemRequestType::RemoveRequestListener:
1987 {
1988 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::RemoveRequestListener> const*>(request.GetData());
1989 g_eventListenerManager.RemoveRequestListener(pRequestData->func, pRequestData->pObjectToListenTo);
1990 result = ERequestStatus::Success;
1991
1992 break;
1993 }
1994 case ESystemRequestType::SetImpl:
1995 {
1996 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::SetImpl> const*>(request.GetData());
1997 result = HandleSetImpl(pRequestData->pIImpl) ? ERequestStatus::Success : ERequestStatus::Failure;
1998
1999 break;
2000 }
2001 case ESystemRequestType::ExecuteTrigger:
2002 {
2003 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ExecuteTrigger> const* const>(request.GetData());
2004
2005 CTrigger const* const pTrigger = stl::find_in_map(g_triggerLookup, pRequestData->triggerId, nullptr);
2006
2007 if (pTrigger != nullptr)
2008 {
2009 pTrigger->Execute(request.pOwner, request.pUserData, request.pUserDataOwner, request.flags);
2010 result = ERequestStatus::Success;
2011 }
2012
2013 break;
2014 }
2015 case ESystemRequestType::ExecuteTriggerWithCallbacks:
2016 {
2017 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ExecuteTriggerWithCallbacks> const* const>(request.GetData());
2018
2019 CTrigger const* const pTrigger = stl::find_in_map(g_triggerLookup, pRequestData->data.triggerId, nullptr);
2020
2021 if (pTrigger != nullptr)
2022 {
2023 pTrigger->ExecuteWithCallbacks(pRequestData->data, request.pOwner, request.pUserData, request.pUserDataOwner, request.flags);
2024 result = ERequestStatus::Success;
2025 }
2026
2027 break;
2028 }
2029 case ESystemRequestType::StopTrigger:
2030 {
2031 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::StopTrigger> const* const>(request.GetData());
2032
2033 CTrigger const* const pTrigger = stl::find_in_map(g_triggerLookup, pRequestData->triggerId, nullptr);
2034
2035 if (pTrigger != nullptr)
2036 {
2037 pTrigger->Stop(g_pIObject);
2038 result = ERequestStatus::Success;
2039 }
2040
2041 break;
2042 }
2043 case ESystemRequestType::StopAllTriggers:
2044 {
2045 g_pIObject->StopAllTriggers();
2046 result = ERequestStatus::Success;
2047
2048 break;
2049 }
2050 case ESystemRequestType::ExecuteTriggerEx:
2051 {
2052 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ExecuteTriggerEx> const*>(request.GetData());
2053
2054 CTrigger const* const pTrigger = stl::find_in_map(g_triggerLookup, pRequestData->triggerId, nullptr);
2055
2056 if (pTrigger != nullptr)
2057 {
2058 Listeners listeners;
2059
2060 for (auto const id : pRequestData->listenerIds)
2061 {
2062 listeners.push_back(g_listenerManager.GetListener(id));
2063 }
2064
2065 Impl::IListeners implListeners;
2066
2067 for (auto const pListener : listeners)
2068 {
2069 implListeners.push_back(pListener->GetImplData());
2070 }
2071
2072 MEMSTAT_CONTEXT(EMemStatContextType::AudioSystem, "CryAudio::CObject");
2073
2074 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2075 auto const pNewObject = new CObject(pRequestData->transformation, pRequestData->name.c_str());
2076 pNewObject->Init(g_pIImpl->ConstructObject(pRequestData->transformation, implListeners, pNewObject->GetName()), listeners);
2077 g_constructedObjects.push_back(pNewObject);
2078 #else
2079 auto const pNewObject = new CObject(pRequestData->transformation);
2080 pNewObject->Init(g_pIImpl->ConstructObject(pRequestData->transformation, implListeners), listeners);
2081 #endif // CRY_AUDIO_USE_DEBUG_CODE
2082
2083 if (pRequestData->setCurrentEnvironments)
2084 {
2085 SetCurrentEnvironmentsOnObject(pNewObject, INVALID_ENTITYID);
2086 }
2087
2088 #if defined(CRY_AUDIO_USE_OCCLUSION)
2089 SetOcclusionType(*pNewObject, pRequestData->occlusionType);
2090 #endif // CRY_AUDIO_USE_OCCLUSION
2091 pTrigger->Execute(*pNewObject, request.pOwner, request.pUserData, request.pUserDataOwner, request.flags, pRequestData->entityId);
2092 pNewObject->RemoveFlag(EObjectFlags::InUse);
2093
2094 if ((pNewObject->GetFlags() & EObjectFlags::Active) == EObjectFlags::None)
2095 {
2096 pNewObject->Destruct();
2097 }
2098
2099 result = ERequestStatus::Success;
2100 }
2101
2102 break;
2103 }
2104 case ESystemRequestType::ExecuteDefaultTrigger:
2105 {
2106 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ExecuteDefaultTrigger> const*>(request.GetData());
2107
2108 switch (pRequestData->triggerType)
2109 {
2110 case EDefaultTriggerType::LoseFocus:
2111 {
2112 if ((g_systemStates& ESystemStates::IsMuted) == ESystemStates::None)
2113 {
2114 g_loseFocusTrigger.Execute();
2115 }
2116
2117 result = ERequestStatus::Success;
2118
2119 break;
2120 }
2121 case EDefaultTriggerType::GetFocus:
2122 {
2123 if ((g_systemStates& ESystemStates::IsMuted) == ESystemStates::None)
2124 {
2125 g_getFocusTrigger.Execute();
2126 }
2127
2128 result = ERequestStatus::Success;
2129
2130 break;
2131 }
2132 case EDefaultTriggerType::MuteAll:
2133 {
2134 g_muteAllTrigger.Execute();
2135 result = ERequestStatus::Success;
2136 g_systemStates |= ESystemStates::IsMuted;
2137
2138 break;
2139 }
2140 case EDefaultTriggerType::UnmuteAll:
2141 {
2142 g_unmuteAllTrigger.Execute();
2143 result = ERequestStatus::Success;
2144 g_systemStates &= ~ESystemStates::IsMuted;
2145
2146 break;
2147 }
2148 case EDefaultTriggerType::PauseAll:
2149 {
2150 g_pauseAllTrigger.Execute();
2151 result = ERequestStatus::Success;
2152
2153 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2154 g_systemStates |= ESystemStates::IsPaused;
2155 #endif // CRY_AUDIO_USE_DEBUG_CODE
2156
2157 break;
2158 }
2159 case EDefaultTriggerType::ResumeAll:
2160 {
2161 g_resumeAllTrigger.Execute();
2162 result = ERequestStatus::Success;
2163
2164 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2165 g_systemStates &= ~ESystemStates::IsPaused;
2166 #endif // CRY_AUDIO_USE_DEBUG_CODE
2167
2168 break;
2169 }
2170 default:
2171 {
2172 break;
2173 }
2174 }
2175
2176 break;
2177 }
2178 case ESystemRequestType::StopAllSounds:
2179 {
2180 g_pIImpl->StopAllSounds();
2181 result = ERequestStatus::Success;
2182
2183 break;
2184 }
2185 case ESystemRequestType::ParseControlsData:
2186 {
2187 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ParseControlsData> const*>(request.GetData());
2188 g_xmlProcessor.ParseControlsData(pRequestData->folderPath.c_str(), pRequestData->contextId, pRequestData->contextName.c_str());
2189
2190 if (pRequestData->contextId != GlobalContextId)
2191 {
2192 ReportContextActivated(pRequestData->contextId);
2193 }
2194
2195 result = ERequestStatus::Success;
2196
2197 break;
2198 }
2199 case ESystemRequestType::ParsePreloadsData:
2200 {
2201 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ParsePreloadsData> const*>(request.GetData());
2202 g_xmlProcessor.ParsePreloadsData(pRequestData->folderPath.c_str(), pRequestData->contextId);
2203
2204 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2205 HandleUpdateDebugInfo(EDebugUpdateFilter::FileCacheManager | EDebugUpdateFilter::Contexts);
2206 #endif // CRY_AUDIO_USE_DEBUG_CODE
2207
2208 result = ERequestStatus::Success;
2209
2210 break;
2211 }
2212 case ESystemRequestType::ClearControlsData:
2213 {
2214 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ClearControlsData> const*>(request.GetData());
2215 g_xmlProcessor.ClearControlsData(pRequestData->contextId, false);
2216
2217 ContextId const id = pRequestData->contextId;
2218
2219 if ((id != GlobalContextId) && (id != InvalidContextId))
2220 {
2221 ReportContextDeactivated(id);
2222 }
2223
2224 result = ERequestStatus::Success;
2225
2226 break;
2227 }
2228 case ESystemRequestType::ClearPreloadsData:
2229 {
2230 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ClearPreloadsData> const*>(request.GetData());
2231 g_xmlProcessor.ClearPreloadsData(pRequestData->contextId, false);
2232
2233 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2234 HandleUpdateDebugInfo(EDebugUpdateFilter::FileCacheManager | EDebugUpdateFilter::Contexts);
2235 #endif // CRY_AUDIO_USE_DEBUG_CODE
2236
2237 result = ERequestStatus::Success;
2238
2239 break;
2240 }
2241 case ESystemRequestType::PreloadSingleRequest:
2242 {
2243 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::PreloadSingleRequest> const*>(request.GetData());
2244 result = g_fileCacheManager.TryLoadRequest(
2245 pRequestData->preloadRequestId,
2246 ((request.flags & ERequestFlags::ExecuteBlocking) != ERequestFlags::None),
2247 pRequestData->bAutoLoadOnly,
2248 request.flags,
2249 request.pOwner,
2250 request.pUserData,
2251 request.pUserDataOwner);
2252
2253 break;
2254 }
2255 case ESystemRequestType::UnloadSingleRequest:
2256 {
2257 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::UnloadSingleRequest> const*>(request.GetData());
2258 result = g_fileCacheManager.TryUnloadRequest(pRequestData->preloadRequestId);
2259
2260 break;
2261 }
2262 case ESystemRequestType::ActivateContext:
2263 {
2264 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ActivateContext> const*>(request.GetData());
2265
2266 HandleActivateContext(pRequestData->contextId);
2267 result = ERequestStatus::Success;
2268
2269 break;
2270 }
2271 case ESystemRequestType::DeactivateContext:
2272 {
2273 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::DeactivateContext> const*>(request.GetData());
2274
2275 HandleDeactivateContext(pRequestData->contextId);
2276 result = ERequestStatus::Success;
2277
2278 break;
2279 }
2280 case ESystemRequestType::SetParameter:
2281 {
2282 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::SetParameter> const*>(request.GetData());
2283
2284 CParameter const* const pParameter = stl::find_in_map(g_parameterLookup, pRequestData->parameterId, nullptr);
2285
2286 if (pParameter != nullptr)
2287 {
2288 pParameter->Set(pRequestData->value);
2289 result = ERequestStatus::Success;
2290 }
2291
2292 break;
2293 }
2294 case ESystemRequestType::SetParameterGlobally:
2295 {
2296 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::SetParameterGlobally> const*>(request.GetData());
2297
2298 CParameter const* const pParameter = stl::find_in_map(g_parameterLookup, pRequestData->parameterId, nullptr);
2299
2300 if (pParameter != nullptr)
2301 {
2302 pParameter->SetGlobally(pRequestData->value);
2303 result = ERequestStatus::Success;
2304 }
2305
2306 break;
2307 }
2308 case ESystemRequestType::SetSwitchState:
2309 {
2310 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::SetSwitchState> const*>(request.GetData());
2311
2312 CSwitch const* const pSwitch = stl::find_in_map(g_switchLookup, pRequestData->switchId, nullptr);
2313
2314 if (pSwitch != nullptr)
2315 {
2316 CSwitchState const* const pState = stl::find_in_map(pSwitch->GetStates(), pRequestData->switchStateId, nullptr);
2317
2318 if (pState != nullptr)
2319 {
2320 pState->Set();
2321 result = ERequestStatus::Success;
2322 }
2323 }
2324
2325 break;
2326 }
2327 case ESystemRequestType::SetSwitchStateGlobally:
2328 {
2329 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::SetSwitchStateGlobally> const*>(request.GetData());
2330
2331 CSwitch const* const pSwitch = stl::find_in_map(g_switchLookup, pRequestData->switchId, nullptr);
2332
2333 if (pSwitch != nullptr)
2334 {
2335 CSwitchState const* const pState = stl::find_in_map(pSwitch->GetStates(), pRequestData->switchStateId, nullptr);
2336
2337 if (pState != nullptr)
2338 {
2339 pState->SetGlobally();
2340 result = ERequestStatus::Success;
2341 }
2342 }
2343
2344 break;
2345 }
2346 case ESystemRequestType::AutoLoadSetting:
2347 {
2348 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::AutoLoadSetting> const*>(request.GetData());
2349
2350 for (auto const& settingPair : g_settingLookup)
2351 {
2352 CSetting const* const pSetting = settingPair.second;
2353
2354 if (pSetting->IsAutoLoad() && (pSetting->GetContextId() == pRequestData->contextId))
2355 {
2356 pSetting->Load();
2357 break;
2358 }
2359 }
2360
2361 result = ERequestStatus::Success;
2362
2363 break;
2364 }
2365 case ESystemRequestType::LoadSetting:
2366 {
2367 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::LoadSetting> const*>(request.GetData());
2368
2369 CSetting const* const pSetting = stl::find_in_map(g_settingLookup, pRequestData->id, nullptr);
2370
2371 if (pSetting != nullptr)
2372 {
2373 pSetting->Load();
2374 result = ERequestStatus::Success;
2375 }
2376
2377 break;
2378 }
2379 case ESystemRequestType::UnloadSetting:
2380 {
2381 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::UnloadSetting> const*>(request.GetData());
2382
2383 CSetting const* const pSetting = stl::find_in_map(g_settingLookup, pRequestData->id, nullptr);
2384
2385 if (pSetting != nullptr)
2386 {
2387 pSetting->Unload();
2388 result = ERequestStatus::Success;
2389 }
2390
2391 break;
2392 }
2393 case ESystemRequestType::UnloadAFCMDataByContext:
2394 {
2395 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::UnloadAFCMDataByContext> const*>(request.GetData());
2396 g_fileCacheManager.UnloadDataByContext(pRequestData->contextId);
2397 result = ERequestStatus::Success;
2398
2399 break;
2400 }
2401 case ESystemRequestType::ReleaseImpl:
2402 {
2403 ReleaseImpl();
2404 result = ERequestStatus::Success;
2405
2406 break;
2407 }
2408 case ESystemRequestType::ChangeLanguage:
2409 {
2410 SetImplLanguage();
2411
2412 g_fileCacheManager.UpdateLocalizedFileCacheEntries();
2413
2414 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2415 HandleUpdateDebugInfo(EDebugUpdateFilter::FileCacheManager);
2416 #endif // CRY_AUDIO_USE_DEBUG_CODE
2417
2418 result = ERequestStatus::Success;
2419
2420 break;
2421 }
2422 #if defined(CRY_AUDIO_USE_OCCLUSION)
2423 case ESystemRequestType::ReleasePendingRays:
2424 {
2425 for (auto const pObject : g_activeObjects)
2426 {
2427 pObject->ReleasePendingRays();
2428 }
2429
2430 result = ERequestStatus::Success;
2431
2432 break;
2433 }
2434 #endif // CRY_AUDIO_USE_OCCLUSION
2435 case ESystemRequestType::GetImplInfo:
2436 {
2437 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::GetImplInfo> const*>(request.GetData());
2438 g_pIImpl->GetInfo(pRequestData->implInfo);
2439 result = ERequestStatus::Success;
2440
2441 break;
2442 }
2443 case ESystemRequestType::RegisterListener:
2444 {
2445 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::RegisterListener> const*>(request.GetData());
2446 *pRequestData->ppListener = g_listenerManager.CreateListener(pRequestData->transformation, pRequestData->name.c_str(), true);
2447 result = ERequestStatus::Success;
2448
2449 break;
2450 }
2451 case ESystemRequestType::ReleaseListener:
2452 {
2453 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ReleaseListener> const*>(request.GetData());
2454
2455 CRY_ASSERT(pRequestData->pListener != nullptr);
2456
2457 if (pRequestData->pListener != nullptr)
2458 {
2459 g_listenerManager.ReleaseListener(pRequestData->pListener);
2460 result = ERequestStatus::Success;
2461 }
2462
2463 break;
2464 }
2465 case ESystemRequestType::GetListener:
2466 {
2467 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::GetListener> const*>(request.GetData());
2468 *pRequestData->ppListener = g_listenerManager.GetListener(pRequestData->id);
2469 result = ERequestStatus::Success;
2470
2471 break;
2472 }
2473 case ESystemRequestType::RegisterObject:
2474 {
2475 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::RegisterObject> const*>(request.GetData());
2476
2477 Listeners listeners;
2478
2479 for (auto const id : pRequestData->listenerIds)
2480 {
2481 listeners.push_back(g_listenerManager.GetListener(id));
2482 }
2483
2484 Impl::IListeners implListeners;
2485 implListeners.reserve(listeners.size());
2486
2487 for (auto const pListener : listeners)
2488 {
2489 implListeners.push_back(pListener->GetImplData());
2490 }
2491
2492 MEMSTAT_CONTEXT(EMemStatContextType::AudioSystem, "CryAudio::CObject");
2493
2494 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2495 auto const pNewObject = new CObject(pRequestData->transformation, pRequestData->name.c_str());
2496 pNewObject->Init(g_pIImpl->ConstructObject(pRequestData->transformation, implListeners, pNewObject->GetName()), listeners);
2497 g_constructedObjects.push_back(pNewObject);
2498 #else
2499 auto const pNewObject = new CObject(pRequestData->transformation);
2500 pNewObject->Init(g_pIImpl->ConstructObject(pRequestData->transformation, implListeners), listeners);
2501 #endif // CRY_AUDIO_USE_DEBUG_CODE
2502
2503 if (pRequestData->setCurrentEnvironments)
2504 {
2505 SetCurrentEnvironmentsOnObject(pNewObject, INVALID_ENTITYID);
2506 }
2507
2508 #if defined(CRY_AUDIO_USE_OCCLUSION)
2509 SetOcclusionType(*pNewObject, pRequestData->occlusionType);
2510 #endif // CRY_AUDIO_USE_OCCLUSION
2511 *pRequestData->ppObject = pNewObject;
2512 result = ERequestStatus::Success;
2513
2514 break;
2515 }
2516 case ESystemRequestType::ReleaseObject:
2517 {
2518 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ReleaseObject> const*>(request.GetData());
2519
2520 pRequestData->pObject->RemoveFlag(EObjectFlags::InUse);
2521
2522 if ((pRequestData->pObject->GetFlags() & EObjectFlags::Active) == EObjectFlags::None)
2523 {
2524 pRequestData->pObject->Destruct();
2525 }
2526
2527 result = ERequestStatus::Success;
2528
2529 break;
2530 }
2531 case ESystemRequestType::None:
2532 {
2533 result = ERequestStatus::Success;
2534
2535 break;
2536 }
2537 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2538 case ESystemRequestType::RefreshSystem:
2539 {
2540 HandleRefresh();
2541 HandleRetriggerControls();
2542 result = ERequestStatus::Success;
2543
2544 break;
2545 }
2546 case ESystemRequestType::ExecutePreviewTrigger:
2547 {
2548 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ExecutePreviewTrigger> const*>(request.GetData());
2549
2550 CTrigger const* const pTrigger = stl::find_in_map(g_triggerLookup, pRequestData->triggerId, nullptr);
2551
2552 if (pTrigger != nullptr)
2553 {
2554 pTrigger->Execute(g_previewObject, request.pOwner, request.pUserData, request.pUserDataOwner, request.flags);
2555 result = ERequestStatus::Success;
2556 }
2557
2558 break;
2559 }
2560 case ESystemRequestType::ExecutePreviewTriggerEx:
2561 {
2562 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ExecutePreviewTriggerEx> const*>(request.GetData());
2563
2564 g_previewTrigger.Execute(pRequestData->triggerInfo);
2565 result = ERequestStatus::Success;
2566
2567 break;
2568 }
2569 case ESystemRequestType::ExecutePreviewTriggerExNode:
2570 {
2571 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ExecutePreviewTriggerExNode> const*>(request.GetData());
2572
2573 g_previewTrigger.Execute(pRequestData->node);
2574 result = ERequestStatus::Success;
2575
2576 break;
2577 }
2578 case ESystemRequestType::StopPreviewTrigger:
2579 {
2580 g_previewObject.StopAllTriggers();
2581 result = ERequestStatus::Success;
2582
2583 break;
2584 }
2585 case ESystemRequestType::RefreshObject:
2586 {
2587 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::RefreshObject> const*>(request.GetData());
2588
2589 for (auto const pObject : g_constructedObjects)
2590 {
2591 if (pObject->GetImplData() == pRequestData->pIObject)
2592 {
2593 pObject->ForceImplementationRefresh();
2594 break;
2595 }
2596 }
2597
2598 result = ERequestStatus::Success;
2599
2600 break;
2601 }
2602 case ESystemRequestType::ResetRequestCount:
2603 {
2604 ZeroStruct(g_requestsPerUpdate);
2605 ZeroStruct(g_requestPeaks);
2606 result = ERequestStatus::Success;
2607
2608 break;
2609 }
2610 case ESystemRequestType::RetriggerControls:
2611 {
2612 HandleRetriggerControls();
2613 result = ERequestStatus::Success;
2614
2615 break;
2616 }
2617 case ESystemRequestType::ReloadControlsData:
2618 {
2619 for (auto const pObject : g_activeObjects)
2620 {
2621 pObject->StopAllTriggers();
2622 }
2623
2624 g_pIObject->StopAllTriggers();
2625 g_previewObject.StopAllTriggers();
2626
2627 // Store active contexts for reloading after they have been unloaded which empties the map.
2628 ContextInfo const tempContextInfo = g_contextInfo;
2629
2630 g_xmlProcessor.ClearControlsData(GlobalContextId, true);
2631 ReportContextDeactivated(GlobalContextId);
2632
2633 g_xmlProcessor.ParseSystemData();
2634 g_xmlProcessor.ParseControlsData(g_configPath.c_str(), GlobalContextId, g_szGlobalContextName);
2635
2636 for (auto const& contextPair : tempContextInfo)
2637 {
2638 ContextId const contextId = contextPair.second.contextId;
2639
2640 if (contextPair.second.isRegistered && contextPair.second.isActive && (contextId != GlobalContextId))
2641 {
2642 char const* const szContextName = contextPair.first.c_str();
2643
2644 CryFixedStringT<MaxFilePathLength> contextPath = g_configPath;
2645 contextPath += g_szContextsFolderName;
2646 contextPath += "/";
2647 contextPath += szContextName;
2648
2649 g_xmlProcessor.ParseControlsData(contextPath.c_str(), contextId, szContextName);
2650
2651 ReportContextActivated(contextId);
2652 }
2653 }
2654
2655 HandleRetriggerControls();
2656
2657 result = ERequestStatus::Success;
2658
2659 break;
2660 }
2661 case ESystemRequestType::DrawDebugInfo:
2662 {
2663 HandleDrawDebug();
2664 m_canDraw = true;
2665 result = ERequestStatus::Success;
2666
2667 break;
2668 }
2669 case ESystemRequestType::UpdateDebugInfo:
2670 {
2671 HandleUpdateDebugInfo(EDebugUpdateFilter::FileCacheManager | EDebugUpdateFilter::Contexts);
2672 result = ERequestStatus::Success;
2673
2674 break;
2675 }
2676 #endif // CRY_AUDIO_USE_DEBUG_CODE
2677 default:
2678 {
2679 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2680 Cry::Audio::Log(ELogType::Warning, "Unknown manager request type: %u", pBase->systemRequestType);
2681 #endif // CRY_AUDIO_USE_DEBUG_CODE
2682
2683 break;
2684 }
2685 }
2686
2687 return result;
2688 }
2689
2690 //////////////////////////////////////////////////////////////////////////
2691 ERequestStatus CSystem::ProcessCallbackRequest(CRequest& request)
2692 {
2693 ERequestStatus result = ERequestStatus::Failure;
2694 auto const pBase = static_cast<SCallbackRequestDataBase const*>(request.GetData());
2695
2696 switch (pBase->callbackRequestType)
2697 {
2698 case ECallbackRequestType::ReportStartedTriggerConnectionInstance:
2699 {
2700 auto const pRequestData = static_cast<SCallbackRequestData<ECallbackRequestType::ReportStartedTriggerConnectionInstance> const*>(request.GetData());
2701
2702 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2703 bool objectFound = false;
2704 #endif // CRY_AUDIO_USE_DEBUG_CODE
2705
2706 CObject* const pObject = stl::find_in_map(g_triggerInstanceIdLookup, pRequestData->triggerInstanceId, nullptr);
2707
2708 if (pObject != nullptr)
2709 {
2710 pObject->ReportStartedTriggerInstance(pRequestData->triggerInstanceId, pRequestData->result);
2711
2712 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2713 objectFound = true;
2714 #endif // CRY_AUDIO_USE_DEBUG_CODE
2715 }
2716 else if (std::find(g_triggerInstanceIds.begin(), g_triggerInstanceIds.end(), pRequestData->triggerInstanceId) != g_triggerInstanceIds.end())
2717 {
2718 ReportStartedGlobalTriggerInstance(pRequestData->triggerInstanceId, pRequestData->result);
2719
2720 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2721 objectFound = true;
2722 #endif // CRY_AUDIO_USE_DEBUG_CODE
2723 }
2724
2725 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2726 CRY_ASSERT_MESSAGE(objectFound, "TriggerInstanceId %u is not mapped to an object during %s", pRequestData->triggerInstanceId, __FUNCTION__);
2727 #endif // CRY_AUDIO_USE_DEBUG_CODE
2728
2729 result = ERequestStatus::Success;
2730
2731 break;
2732 }
2733 case ECallbackRequestType::ReportFinishedTriggerConnectionInstance:
2734 {
2735 auto const pRequestData = static_cast<SCallbackRequestData<ECallbackRequestType::ReportFinishedTriggerConnectionInstance> const*>(request.GetData());
2736
2737 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2738 bool objectFound = false;
2739 #endif // CRY_AUDIO_USE_DEBUG_CODE
2740
2741 CObject* const pObject = stl::find_in_map(g_triggerInstanceIdLookup, pRequestData->triggerInstanceId, nullptr);
2742
2743 if (pObject != nullptr)
2744 {
2745 pObject->ReportFinishedTriggerInstance(pRequestData->triggerInstanceId, pRequestData->result);
2746
2747 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2748 objectFound = true;
2749 #endif // CRY_AUDIO_USE_DEBUG_CODE
2750
2751 }
2752 else if (std::find(g_triggerInstanceIds.begin(), g_triggerInstanceIds.end(), pRequestData->triggerInstanceId) != g_triggerInstanceIds.end())
2753 {
2754 ReportFinishedTriggerInstance(pRequestData->triggerInstanceId, pRequestData->result);
2755
2756 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2757 objectFound = true;
2758 #endif // CRY_AUDIO_USE_DEBUG_CODE
2759 }
2760
2761 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2762 CRY_ASSERT_MESSAGE(objectFound, "TriggerInstanceId %u is not mapped to an object during %s", pRequestData->triggerInstanceId, __FUNCTION__);
2763 #endif // CRY_AUDIO_USE_DEBUG_CODE
2764
2765 result = ERequestStatus::Success;
2766
2767 break;
2768 }
2769 case ECallbackRequestType::ReportTriggerConnectionInstanceCallback:
2770 {
2771 auto const pRequestData = static_cast<SCallbackRequestData<ECallbackRequestType::ReportTriggerConnectionInstanceCallback> const*>(request.GetData());
2772
2773 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2774 bool objectFound = false;
2775 #endif // CRY_AUDIO_USE_DEBUG_CODE
2776
2777 CObject* const pObject = stl::find_in_map(g_triggerInstanceIdLookup, pRequestData->triggerInstanceId, nullptr);
2778
2779 if (pObject != nullptr)
2780 {
2781 pObject->ReportTriggerInstanceCallback(pRequestData->triggerInstanceId, pRequestData->events);
2782
2783 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2784 objectFound = true;
2785 #endif // CRY_AUDIO_USE_DEBUG_CODE
2786
2787 }
2788 else if (std::find(g_triggerInstanceIds.begin(), g_triggerInstanceIds.end(), pRequestData->triggerInstanceId) != g_triggerInstanceIds.end())
2789 {
2790 ReportTriggerInstanceCallback(pRequestData->triggerInstanceId, pRequestData->events);
2791
2792 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2793 objectFound = true;
2794 #endif // CRY_AUDIO_USE_DEBUG_CODE
2795 }
2796
2797 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2798 CRY_ASSERT_MESSAGE(objectFound, "TriggerInstanceId %u is not mapped to an object during %s", pRequestData->triggerInstanceId, __FUNCTION__);
2799 #endif // CRY_AUDIO_USE_DEBUG_CODE
2800
2801 result = ERequestStatus::Success;
2802
2803 break;
2804 }
2805 case ECallbackRequestType::ReportPhysicalizedObject:
2806 {
2807 auto const pRequestData = static_cast<SCallbackRequestData<ECallbackRequestType::ReportPhysicalizedObject> const*>(request.GetData());
2808
2809 for (auto const pObject : g_activeObjects)
2810 {
2811 if (pObject->GetImplData() == pRequestData->pIObject)
2812 {
2813 pObject->RemoveFlag(EObjectFlags::Virtual);
2814
2815 #if defined(CRY_AUDIO_USE_DEBUG_CODE) && defined(CRY_AUDIO_USE_OCCLUSION)
2816 pObject->ResetObstructionRays();
2817 #endif // CRY_AUDIO_USE_DEBUG_CODE && CRY_AUDIO_USE_OCCLUSION
2818
2819 break;
2820 }
2821 }
2822
2823 result = ERequestStatus::Success;
2824
2825 break;
2826 }
2827 case ECallbackRequestType::ReportVirtualizedObject:
2828 {
2829 auto const pRequestData = static_cast<SCallbackRequestData<ECallbackRequestType::ReportVirtualizedObject> const*>(request.GetData());
2830
2831 for (auto const pObject : g_activeObjects)
2832 {
2833 if (pObject->GetImplData() == pRequestData->pIObject)
2834 {
2835 pObject->SetFlag(EObjectFlags::Virtual);
2836 break;
2837 }
2838 }
2839
2840 result = ERequestStatus::Success;
2841
2842 break;
2843 }
2844 case ECallbackRequestType::ReportFinishedTriggerInstance: // Intentional fall-through.
2845 case ECallbackRequestType::ReportContextActivated: // Intentional fall-through.
2846 case ECallbackRequestType::ReportContextDeactivated: // Intentional fall-through.
2847 case ECallbackRequestType::ReportFinishedPreload: // Intentional fall-through.
2848 case ECallbackRequestType::None:
2849 {
2850 result = ERequestStatus::Success;
2851
2852 break;
2853 }
2854 default:
2855 {
2856 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2857 Cry::Audio::Log(ELogType::Warning, "Unknown callback manager request type: %u", pBase->callbackRequestType);
2858 #endif // CRY_AUDIO_USE_DEBUG_CODE
2859
2860 break;
2861 }
2862 }
2863
2864 return result;
2865 }
2866
2867 //////////////////////////////////////////////////////////////////////////
2868 ERequestStatus CSystem::ProcessObjectRequest(CRequest const& request)
2869 {
2870 ERequestStatus result = ERequestStatus::Failure;
2871
2872 auto const pBase = static_cast<SObjectRequestDataBase const*>(request.GetData());
2873 CObject* const pObject = pBase->pObject;
2874
2875 switch (pBase->objectRequestType)
2876 {
2877 case EObjectRequestType::ExecuteTrigger:
2878 {
2879 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::ExecuteTrigger> const*>(request.GetData());
2880
2881 CTrigger const* const pTrigger = stl::find_in_map(g_triggerLookup, pRequestData->triggerId, nullptr);
2882
2883 if (pTrigger != nullptr)
2884 {
2885 pTrigger->Execute(*pObject, request.pOwner, request.pUserData, request.pUserDataOwner, request.flags, pRequestData->entityId);
2886 result = ERequestStatus::Success;
2887 }
2888
2889 break;
2890 }
2891 case EObjectRequestType::ExecuteTriggerWithCallbacks:
2892 {
2893 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::ExecuteTriggerWithCallbacks> const*>(request.GetData());
2894
2895 CTrigger const* const pTrigger = stl::find_in_map(g_triggerLookup, pRequestData->data.triggerId, nullptr);
2896
2897 if (pTrigger != nullptr)
2898 {
2899 pTrigger->ExecuteWithCallbacks(*pObject, pRequestData->data, request.pOwner, request.pUserData, request.pUserDataOwner, request.flags, pRequestData->entityId);
2900 result = ERequestStatus::Success;
2901 }
2902
2903 break;
2904 }
2905 case EObjectRequestType::StopTrigger:
2906 {
2907 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::StopTrigger> const*>(request.GetData());
2908
2909 CTrigger const* const pTrigger = stl::find_in_map(g_triggerLookup, pRequestData->triggerId, nullptr);
2910
2911 if (pTrigger != nullptr)
2912 {
2913 pTrigger->Stop(pObject->GetImplData());
2914 result = ERequestStatus::Success;
2915 }
2916
2917 break;
2918 }
2919 case EObjectRequestType::StopAllTriggers:
2920 {
2921 pObject->StopAllTriggers();
2922 result = ERequestStatus::Success;
2923
2924 break;
2925 }
2926 case EObjectRequestType::SetTransformation:
2927 {
2928 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::SetTransformation> const*>(request.GetData());
2929
2930 pObject->HandleSetTransformation(pRequestData->transformation);
2931 result = ERequestStatus::Success;
2932
2933 break;
2934 }
2935 case EObjectRequestType::SetParameter:
2936 {
2937 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::SetParameter> const*>(request.GetData());
2938
2939 CParameter const* const pParameter = stl::find_in_map(g_parameterLookup, pRequestData->parameterId, nullptr);
2940
2941 if (pParameter != nullptr)
2942 {
2943 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2944 pParameter->Set(*pObject, pRequestData->value);
2945 #else
2946 pParameter->Set(pObject->GetImplData(), pRequestData->value);
2947 #endif // CRY_AUDIO_USE_DEBUG_CODE
2948
2949 result = ERequestStatus::Success;
2950 }
2951
2952 break;
2953 }
2954 case EObjectRequestType::SetSwitchState:
2955 {
2956 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::SetSwitchState> const*>(request.GetData());
2957
2958 CSwitch const* const pSwitch = stl::find_in_map(g_switchLookup, pRequestData->switchId, nullptr);
2959
2960 if (pSwitch != nullptr)
2961 {
2962 CSwitchState const* const pState = stl::find_in_map(pSwitch->GetStates(), pRequestData->switchStateId, nullptr);
2963
2964 if (pState != nullptr)
2965 {
2966 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
2967 pState->Set(*pObject);
2968 #else
2969 pState->Set(pObject->GetImplData());
2970 #endif // CRY_AUDIO_USE_DEBUG_CODE
2971
2972 result = ERequestStatus::Success;
2973 }
2974 }
2975
2976 break;
2977 }
2978 #if defined(CRY_AUDIO_USE_OCCLUSION)
2979 case EObjectRequestType::SetOcclusionType:
2980 {
2981 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::SetOcclusionType> const*>(request.GetData());
2982
2983 SetOcclusionType(*pObject, pRequestData->occlusionType);
2984 result = ERequestStatus::Success;
2985
2986 break;
2987 }
2988 case EObjectRequestType::SetOcclusionRayOffset:
2989 {
2990 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::SetOcclusionRayOffset> const*>(request.GetData());
2991
2992 pObject->HandleSetOcclusionRayOffset(pRequestData->occlusionRayOffset);
2993 result = ERequestStatus::Success;
2994
2995 break;
2996 }
2997 #endif // CRY_AUDIO_USE_OCCLUSION
2998 case EObjectRequestType::SetCurrentEnvironments:
2999 {
3000 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::SetCurrentEnvironments> const*>(request.GetData());
3001
3002 SetCurrentEnvironmentsOnObject(pObject, pRequestData->entityToIgnore);
3003
3004 break;
3005 }
3006 case EObjectRequestType::SetEnvironment:
3007 {
3008 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::SetEnvironment> const*>(request.GetData());
3009
3010 CEnvironment const* const pEnvironment = stl::find_in_map(g_environmentLookup, pRequestData->environmentId, nullptr);
3011
3012 if (pEnvironment != nullptr)
3013 {
3014 pEnvironment->Set(*pObject, pRequestData->amount);
3015 result = ERequestStatus::Success;
3016 }
3017
3018 break;
3019 }
3020 #if defined(CRY_AUDIO_USE_OCCLUSION)
3021 case EObjectRequestType::ProcessPhysicsRay:
3022 {
3023 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::ProcessPhysicsRay> const*>(request.GetData());
3024
3025 pObject->ProcessPhysicsRay(pRequestData->rayInfo);
3026 result = ERequestStatus::Success;
3027
3028 break;
3029 }
3030 #endif // CRY_AUDIO_USE_OCCLUSION
3031 case EObjectRequestType::AddListener:
3032 {
3033 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::AddListener> const*>(request.GetData());
3034
3035 pObject->HandleAddListener(pRequestData->listenerId);
3036 result = ERequestStatus::Success;
3037
3038 break;
3039 }
3040 case EObjectRequestType::RemoveListener:
3041 {
3042 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::RemoveListener> const*>(request.GetData());
3043
3044 pObject->HandleRemoveListener(pRequestData->listenerId);
3045 result = ERequestStatus::Success;
3046
3047 break;
3048 }
3049 case EObjectRequestType::ToggleAbsoluteVelocityTracking:
3050 {
3051 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::ToggleAbsoluteVelocityTracking> const*>(request.GetData());
3052
3053 if (pRequestData->isEnabled)
3054 {
3055 pObject->GetImplData()->ToggleFunctionality(EObjectFunctionality::TrackAbsoluteVelocity, true);
3056
3057 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3058 pObject->SetFlag(EObjectFlags::TrackAbsoluteVelocity);
3059 #endif // CRY_AUDIO_USE_DEBUG_CODE
3060 }
3061 else
3062 {
3063 pObject->GetImplData()->ToggleFunctionality(EObjectFunctionality::TrackAbsoluteVelocity, false);
3064
3065 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3066 pObject->RemoveFlag(EObjectFlags::TrackAbsoluteVelocity);
3067 #endif // CRY_AUDIO_USE_DEBUG_CODE
3068 }
3069
3070 result = ERequestStatus::Success;
3071 break;
3072 }
3073 case EObjectRequestType::ToggleRelativeVelocityTracking:
3074 {
3075 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::ToggleRelativeVelocityTracking> const*>(request.GetData());
3076
3077 if (pRequestData->isEnabled)
3078 {
3079 pObject->GetImplData()->ToggleFunctionality(EObjectFunctionality::TrackRelativeVelocity, true);
3080
3081 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3082 pObject->SetFlag(EObjectFlags::TrackRelativeVelocity);
3083 #endif // CRY_AUDIO_USE_DEBUG_CODE
3084 }
3085 else
3086 {
3087 pObject->GetImplData()->ToggleFunctionality(EObjectFunctionality::TrackRelativeVelocity, false);
3088
3089 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3090 pObject->RemoveFlag(EObjectFlags::TrackRelativeVelocity);
3091 #endif // CRY_AUDIO_USE_DEBUG_CODE
3092 }
3093
3094 result = ERequestStatus::Success;
3095 break;
3096 }
3097 case EObjectRequestType::None:
3098 {
3099 result = ERequestStatus::Success;
3100 break;
3101 }
3102 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3103 case EObjectRequestType::SetName:
3104 {
3105 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::SetName> const*>(request.GetData());
3106
3107 pObject->HandleSetName(pRequestData->name.c_str());
3108 result = ERequestStatus::Success;
3109
3110 break;
3111 }
3112 #endif // CRY_AUDIO_USE_DEBUG_CODE
3113 default:
3114 {
3115 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3116 Cry::Audio::Log(ELogType::Warning, "Unknown object request type: %u", pBase->objectRequestType);
3117 #endif // CRY_AUDIO_USE_DEBUG_CODE
3118
3119 break;
3120 }
3121 }
3122
3123 return result;
3124 }
3125
3126 //////////////////////////////////////////////////////////////////////////
3127 ERequestStatus CSystem::ProcessListenerRequest(SRequestData const* const pPassedRequestData)
3128 {
3129 ERequestStatus result = ERequestStatus::Failure;
3130 auto const pBase = static_cast<SListenerRequestDataBase const*>(pPassedRequestData);
3131
3132 switch (pBase->listenerRequestType)
3133 {
3134 case EListenerRequestType::SetTransformation:
3135 {
3136 auto const pRequestData = static_cast<SListenerRequestData<EListenerRequestType::SetTransformation> const* const>(pPassedRequestData);
3137
3138 CRY_ASSERT(pRequestData->pListener != nullptr);
3139
3140 if (pRequestData->pListener != nullptr)
3141 {
3142 pRequestData->pListener->HandleSetTransformation(pRequestData->transformation);
3143 }
3144
3145 result = ERequestStatus::Success;
3146
3147 break;
3148 }
3149
3150 case EListenerRequestType::None:
3151 {
3152 result = ERequestStatus::Success;
3153
3154 break;
3155 }
3156
3157 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3158 case EListenerRequestType::SetName:
3159 {
3160 auto const pRequestData = static_cast<SListenerRequestData<EListenerRequestType::SetName> const*>(pPassedRequestData);
3161
3162 pRequestData->pListener->HandleSetName(pRequestData->name.c_str());
3163 result = ERequestStatus::Success;
3164
3165 break;
3166 }
3167 #endif // CRY_AUDIO_USE_DEBUG_CODE
3168 default:
3169 {
3170 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3171 Cry::Audio::Log(ELogType::Warning, "Unknown listener request type: %u", pBase->listenerRequestType);
3172 #endif // CRY_AUDIO_USE_DEBUG_CODE
3173
3174 break;
3175 }
3176 }
3177
3178 return result;
3179 }
3180
3181 //////////////////////////////////////////////////////////////////////////
3182 void CSystem::NotifyListener(CRequest const& request)
3183 {
3184 ESystemEvents systemEvent = ESystemEvents::None;
3185 ControlId controlID = InvalidControlId;
3186 EntityId entityId = INVALID_ENTITYID;
3187
3188 switch (request.GetData()->requestType)
3189 {
3190 case ERequestType::SystemRequest:
3191 {
3192 auto const pBase = static_cast<SSystemRequestDataBase const*>(request.GetData());
3193
3194 switch (pBase->systemRequestType)
3195 {
3196 case ESystemRequestType::SetImpl:
3197 {
3198 systemEvent = ESystemEvents::ImplSet;
3199
3200 break;
3201 }
3202 case ESystemRequestType::ExecuteTrigger:
3203 {
3204 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ExecuteTrigger> const*>(pBase);
3205 controlID = pRequestData->triggerId;
3206 systemEvent = ESystemEvents::TriggerExecuted;
3207
3208 break;
3209 }
3210 case ESystemRequestType::ExecuteTriggerWithCallbacks:
3211 {
3212 auto const pRequestData = static_cast<SSystemRequestData<ESystemRequestType::ExecuteTriggerWithCallbacks> const*>(pBase);
3213 controlID = pRequestData->data.triggerId;
3214 systemEvent = ESystemEvents::TriggerExecuted;
3215
3216 break;
3217 }
3218 default:
3219 {
3220 break;
3221 }
3222 }
3223
3224 break;
3225 }
3226 case ERequestType::CallbackRequest:
3227 {
3228 auto const pBase = static_cast<SCallbackRequestDataBase const*>(request.GetData());
3229
3230 switch (pBase->callbackRequestType)
3231 {
3232 case ECallbackRequestType::ReportFinishedTriggerInstance:
3233 {
3234 auto const pRequestData = static_cast<SCallbackRequestData<ECallbackRequestType::ReportFinishedTriggerInstance> const*>(pBase);
3235 controlID = pRequestData->triggerId;
3236 entityId = pRequestData->entityId;
3237 systemEvent = ESystemEvents::TriggerFinished;
3238
3239 break;
3240 }
3241 case ECallbackRequestType::ReportTriggerConnectionInstanceCallback:
3242 {
3243 auto const pRequestData = static_cast<SCallbackRequestData<ECallbackRequestType::ReportTriggerConnectionInstanceCallback> const*>(pBase);
3244 systemEvent = pRequestData->events;
3245
3246 break;
3247 }
3248 case ECallbackRequestType::SendTriggerInstanceCallback:
3249 {
3250 auto const pRequestData = static_cast<SCallbackRequestData<ECallbackRequestType::SendTriggerInstanceCallback> const*>(pBase);
3251 controlID = pRequestData->triggerId;
3252 entityId = pRequestData->entityId;
3253 systemEvent = pRequestData->events;
3254
3255 break;
3256 }
3257 case ECallbackRequestType::ReportContextActivated:
3258 {
3259 systemEvent = ESystemEvents::ContextActivated;
3260
3261 break;
3262 }
3263 case ECallbackRequestType::ReportContextDeactivated:
3264 {
3265 systemEvent = ESystemEvents::ContextDeactivated;
3266
3267 break;
3268 }
3269 case ECallbackRequestType::ReportFinishedPreload:
3270 {
3271 auto const pRequestData = static_cast<SCallbackRequestData<ECallbackRequestType::ReportFinishedPreload> const*>(pBase);
3272 controlID = static_cast<ControlId>(pRequestData->preloadRequestId);
3273 systemEvent = pRequestData->isFullSuccess ? ESystemEvents::PreloadFinishedSuccess : ESystemEvents::PreloadFinishedFailure;
3274
3275 break;
3276 }
3277 default:
3278 {
3279 break;
3280 }
3281 }
3282
3283 break;
3284 }
3285 case ERequestType::ObjectRequest:
3286 {
3287 auto const pBase = static_cast<SObjectRequestDataBase const*>(request.GetData());
3288
3289 switch (pBase->objectRequestType)
3290 {
3291 case EObjectRequestType::ExecuteTrigger:
3292 {
3293 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::ExecuteTrigger> const*>(pBase);
3294 controlID = pRequestData->triggerId;
3295 entityId = pRequestData->entityId;
3296 systemEvent = ESystemEvents::TriggerExecuted;
3297
3298 break;
3299 }
3300 case EObjectRequestType::ExecuteTriggerWithCallbacks:
3301 {
3302 auto const pRequestData = static_cast<SObjectRequestData<EObjectRequestType::ExecuteTriggerWithCallbacks> const*>(pBase);
3303 controlID = pRequestData->data.triggerId;
3304 entityId = pRequestData->entityId;
3305 systemEvent = ESystemEvents::TriggerExecuted;
3306
3307 break;
3308 }
3309 default:
3310 {
3311 break;
3312 }
3313 }
3314
3315 break;
3316 }
3317 case ERequestType::ListenerRequest:
3318 {
3319 // Nothing to do currently for this type of request.
3320
3321 break;
3322 }
3323 default:
3324 {
3325 CryFatalError("Unknown request type during %s!", __FUNCTION__);
3326
3327 break;
3328 }
3329 }
3330
3331 ERequestResult result = ERequestResult::Failure;
3332
3333 switch (request.status)
3334 {
3335 case ERequestStatus::Success:
3336 {
3337 result = ERequestResult::Success;
3338 break;
3339 }
3340 case ERequestStatus::Failure:
3341 {
3342 result = ERequestResult::Failure;
3343 break;
3344 }
3345 default:
3346 {
3347 CRY_ASSERT_MESSAGE(false, "Invalid request status '%u'. Cannot be converted to a request result during %s", request.status, __FUNCTION__);
3348 result = ERequestResult::Failure;
3349 break;
3350 }
3351 }
3352
3353 SRequestInfo const requestInfo(
3354 result,
3355 request.pOwner,
3356 request.pUserData,
3357 request.pUserDataOwner,
3358 systemEvent,
3359 controlID,
3360 entityId);
3361
3362 g_eventListenerManager.NotifyListener(&requestInfo);
3363 }
3364
3365 //////////////////////////////////////////////////////////////////////////
3366 bool CSystem::HandleSetImpl(Impl::IImpl* const pIImpl)
3367 {
3368 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3369 ContextInfo const tempContextInfo = g_contextInfo;
3370 #endif // CRY_AUDIO_USE_DEBUG_CODE
3371
3372 if ((g_pIImpl != nullptr) && (pIImpl != g_pIImpl))
3373 {
3374 ReleaseImpl();
3375 }
3376
3377 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3378 g_contextInfo.clear();
3379 g_contextInfo.insert(tempContextInfo.begin(), tempContextInfo.end());
3380 #endif // CRY_AUDIO_USE_DEBUG_CODE
3381
3382 g_pIImpl = pIImpl;
3383
3384 if (g_pIImpl == nullptr)
3385 {
3386 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3387 Cry::Audio::Log(ELogType::Warning, "nullptr passed to SetImpl, will run with the null implementation");
3388 #endif // CRY_AUDIO_USE_DEBUG_CODE
3389
3390 MEMSTAT_CONTEXT(EMemStatContextType::AudioSystem, "CryAudio::Impl::Null::CImpl");
3391 auto const pImpl = new Impl::Null::CImpl();
3392 CRY_ASSERT(pImpl != nullptr);
3393 g_pIImpl = static_cast<Impl::IImpl*>(pImpl);
3394 }
3395
3396 g_xmlProcessor.ParseSystemData();
3397
3398 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3399 if ((g_systemStates& ESystemStates::PoolsAllocated) == ESystemStates::None)
3400 {
3401 // Don't allocate again after impl switch.
3402 AllocateMemoryPools();
3403 g_systemStates |= ESystemStates::PoolsAllocated;
3404 }
3405 #else
3406 AllocateMemoryPools();
3407 #endif // CRY_AUDIO_USE_DEBUG_CODE
3408
3409 bool const isInitialized = g_pIImpl->Init(m_objectPoolSize);
3410
3411 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3412 // Get impl info again (was done in ParseSystemData) to set the impl name, because
3413 // it's not guaranteed that it already existed in the impl constructor.
3414 g_pIImpl->GetInfo(g_implInfo);
3415 #endif // CRY_AUDIO_USE_DEBUG_CODE
3416
3417 if (!isInitialized)
3418 {
3419 // The impl failed to initialize, allow it to shut down and release then fall back to the null impl.
3420
3421 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3422 Cry::Audio::Log(ELogType::Error, "Failed to set the AudioImpl %s. Will run with the null implementation.", g_implInfo.name);
3423 #endif // CRY_AUDIO_USE_DEBUG_CODE
3424
3425 // There's no need to call Shutdown when the initialization failed as
3426 // we expect the implementation to clean-up itself if it couldn't be initialized
3427
3428 g_pIImpl->Release(); // Release the engine specific data.
3429
3430 MEMSTAT_CONTEXT(EMemStatContextType::AudioSystem, "CryAudio::Impl::Null::CImpl");
3431 auto const pImpl = new Impl::Null::CImpl();
3432 CRY_ASSERT(pImpl != nullptr);
3433 g_pIImpl = static_cast<Impl::IImpl*>(pImpl);
3434 }
3435
3436 CRY_ASSERT_MESSAGE(g_defaultListener.GetImplData() == nullptr, "<Audio> The default listeners's impl-data must be nullptr during %s", __FUNCTION__);
3437
3438 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3439 g_defaultListener.SetImplData(g_pIImpl->ConstructListener(g_defaultListener.GetDebugTransformation(), g_szDefaultListenerName));
3440 #else
3441 g_defaultListener.SetImplData(g_pIImpl->ConstructListener(CTransformation::GetEmptyObject(), g_szDefaultListenerName));
3442 #endif // CRY_AUDIO_USE_DEBUG_CODE
3443
3444 CRY_ASSERT_MESSAGE(g_pIObject == nullptr, "<Audio> g_pIObject must be nullptr during %s", __FUNCTION__);
3445 Impl::IListeners const defaultImplListener{ g_defaultListener.GetImplData() };
3446
3447 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3448 g_pIObject = g_pIImpl->ConstructObject(CTransformation::GetEmptyObject(), defaultImplListener, g_szGlobalName);
3449 #else
3450 g_pIObject = g_pIImpl->ConstructObject(CTransformation::GetEmptyObject(), defaultImplListener);
3451 #endif // CRY_AUDIO_USE_DEBUG_CODE
3452
3453 string const listenerNames = g_cvars.m_pListeners->GetString();
3454
3455 if (!listenerNames.empty())
3456 {
3457 int curPos = 0;
3458 string listenerName = listenerNames.Tokenize(",", curPos);
3459
3460 while (!listenerName.empty())
3461 {
3462 listenerName.Trim();
3463
3464 if (g_listenerManager.GetListener(StringToId(listenerName.c_str())) == &g_defaultListener)
3465 {
3466 g_listenerManager.CreateListener(CTransformation::GetEmptyObject(), listenerName.c_str(), false);
3467 }
3468
3469 listenerName = listenerNames.Tokenize(",", curPos);
3470 }
3471 }
3472
3473 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3474 CRY_ASSERT_MESSAGE(g_previewListener.GetImplData() == nullptr, "<Audio> The preview listeners's impl-data must be nullptr during %s", __FUNCTION__);
3475 g_previewListener.SetImplData(g_pIImpl->ConstructListener(CTransformation::GetEmptyObject(), g_szPreviewListenerName));
3476
3477 CRY_ASSERT_MESSAGE(g_previewObject.GetImplData() == nullptr, "<Audio> The preview object's impl-data must be nullptr during %s", __FUNCTION__);
3478 Impl::IListeners const previewImplListener{ g_previewListener.GetImplData() };
3479 g_previewObject.SetImplData(g_pIImpl->ConstructObject(CTransformation::GetEmptyObject(), previewImplListener, g_previewObject.GetName()));
3480 g_previewObject.SetFlag(EObjectFlags::IgnoreDrawDebugInfo);
3481
3482 g_listenerManager.ReconstructImplData();
3483
3484 for (auto const pObject : g_constructedObjects)
3485 {
3486 CRY_ASSERT_MESSAGE(pObject->GetImplData() == nullptr, "<Audio> The object's impl-data must be nullptr during %s", __FUNCTION__);
3487
3488 Listeners const& listeners = pObject->GetListeners();
3489 Impl::IListeners implListeners;
3490
3491 for (auto const pListener : listeners)
3492 {
3493 implListeners.push_back(pListener->GetImplData());
3494 }
3495
3496 pObject->SetImplData(g_pIImpl->ConstructObject(pObject->GetTransformation(), implListeners, pObject->GetName()));
3497 }
3498
3499 for (auto const& contextPair : g_contextInfo)
3500 {
3501 ContextId const contextId = contextPair.second.contextId;
3502
3503 if (contextPair.second.isRegistered && contextPair.second.isActive && (contextId != GlobalContextId))
3504 {
3505 char const* const szContextName = contextPair.first.c_str();
3506
3507 CryFixedStringT<MaxFilePathLength> contextPath = g_configPath;
3508 contextPath += g_szContextsFolderName;
3509 contextPath += "/";
3510 contextPath += szContextName;
3511
3512 g_xmlProcessor.ParseControlsData(contextPath.c_str(), contextId, szContextName);
3513 g_xmlProcessor.ParsePreloadsData(contextPath.c_str(), contextId);
3514
3515 auto const preloadRequestId = static_cast<PreloadRequestId>(contextId);
3516
3517 if (g_fileCacheManager.TryLoadRequest(preloadRequestId, true, true) != ERequestStatus::Success)
3518 {
3519 Cry::Audio::Log(ELogType::Warning, R"(No preload request found for context - "%s"!)", szContextName);
3520 }
3521
3522 AutoLoadSetting(contextId);
3523 ReportContextActivated(contextId);
3524 }
3525 }
3526
3527 HandleUpdateDebugInfo(EDebugUpdateFilter::FileCacheManager | EDebugUpdateFilter::Contexts);
3528 #endif // CRY_AUDIO_USE_DEBUG_CODE
3529
3530 SetImplLanguage();
3531
3532 return isInitialized;
3533 }
3534
3535 //////////////////////////////////////////////////////////////////////////
3536 void CSystem::SetImplLanguage()
3537 {
3538 if (ICVar* pCVar = gEnv->pConsole->GetCVar("g_languageAudio"))
3539 {
3540 g_pIImpl->SetLanguage(pCVar->GetString());
3541 }
3542 }
3543
3544 //////////////////////////////////////////////////////////////////////////
3545 void CSystem::HandleActivateContext(ContextId const contextId)
3546 {
3547 CryFixedStringT<MaxFileNameLength> const contextName = stl::find_in_map(g_contextLookup, contextId, "");
3548
3549 if (!contextName.empty())
3550 {
3551 CryFixedStringT<MaxFilePathLength> contextPath = g_configPath;
3552 contextPath += g_szContextsFolderName;
3553 contextPath += "/";
3554 contextPath += contextName.c_str();
3555
3556 if (g_xmlProcessor.ParseControlsData(contextPath.c_str(), contextId, contextName.c_str()))
3557 {
3558 g_xmlProcessor.ParsePreloadsData(contextPath.c_str(), contextId);
3559
3560 for (auto const& preloadPair : g_preloadRequests)
3561 {
3562 if (preloadPair.second->GetContextId() == contextId)
3563 {
3564 g_fileCacheManager.TryLoadRequest(preloadPair.second->GetId(), true, true);
3565 }
3566 }
3567
3568 AutoLoadSetting(contextId);
3569 ReportContextActivated(contextId);
3570 }
3571
3572 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3573 HandleUpdateDebugInfo(EDebugUpdateFilter::FileCacheManager | EDebugUpdateFilter::Contexts);
3574 #endif // CRY_AUDIO_USE_DEBUG_CODE
3575 }
3576 }
3577
3578 //////////////////////////////////////////////////////////////////////////
3579 void CSystem::HandleDeactivateContext(ContextId const contextId)
3580 {
3581 g_xmlProcessor.ClearControlsData(contextId, false);
3582 g_xmlProcessor.ClearPreloadsData(contextId, false);
3583
3584 for (auto const& preloadPair : g_preloadRequests)
3585 {
3586 if (preloadPair.second->GetContextId() == contextId)
3587 {
3588 g_fileCacheManager.TryUnloadRequest(preloadPair.second->GetId());
3589 }
3590 }
3591
3592 ReportContextDeactivated(contextId);
3593
3594 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3595 HandleUpdateDebugInfo(EDebugUpdateFilter::FileCacheManager | EDebugUpdateFilter::Contexts);
3596 #endif // CRY_AUDIO_USE_DEBUG_CODE
3597 }
3598
3599 //////////////////////////////////////////////////////////////////////////
3600 void CSystem::ReportContextActivated(ContextId const id)
3601 {
3602 SCallbackRequestData<ECallbackRequestType::ReportContextActivated> const requestData;
3603 CRequest const request(
3604 &requestData,
3605 ERequestFlags::CallbackOnExternalOrCallingThread,
3606 nullptr,
3607 reinterpret_cast<void*>(static_cast<uintptr_t>(id)));
3608 PushRequest(request);
3609 }
3610
3611 //////////////////////////////////////////////////////////////////////////
3612 void CSystem::ReportContextDeactivated(ContextId const id)
3613 {
3614 // Use GlobalContextId when all contexts have been deactivated.
3615
3616 SCallbackRequestData<ECallbackRequestType::ReportContextDeactivated> const requestData;
3617 CRequest const request(
3618 &requestData,
3619 ERequestFlags::CallbackOnExternalOrCallingThread,
3620 nullptr,
3621 reinterpret_cast<void*>(static_cast<uintptr_t>(id)));
3622 PushRequest(request);
3623 }
3624
3625 //////////////////////////////////////////////////////////////////////////
3626 void CSystem::SetCurrentEnvironmentsOnObject(CObject* const pObject, EntityId const entityToIgnore)
3627 {
3628 IAreaManager* const pIAreaManager = gEnv->pEntitySystem->GetAreaManager();
3629 size_t numAreas = 0;
3630 static size_t const s_maxAreas = 10;
3631 static SAudioAreaInfo s_areaInfos[s_maxAreas];
3632
3633 if (pIAreaManager->QueryAudioAreas(pObject->GetTransformation().GetPosition(), s_areaInfos, s_maxAreas, numAreas))
3634 {
3635 for (size_t i = 0; i < numAreas; ++i)
3636 {
3637 SAudioAreaInfo const& areaInfo = s_areaInfos[i];
3638
3639 if (entityToIgnore == INVALID_ENTITYID || entityToIgnore != areaInfo.envProvidingEntityId)
3640 {
3641 CEnvironment const* const pEnvironment = stl::find_in_map(g_environmentLookup, areaInfo.audioEnvironmentId, nullptr);
3642
3643 if (pEnvironment != nullptr)
3644 {
3645 pEnvironment->Set(*pObject, areaInfo.amount);
3646 }
3647 }
3648 }
3649 }
3650 }
3651
3652 #if defined(CRY_AUDIO_USE_OCCLUSION)
3653 //////////////////////////////////////////////////////////////////////////
3654 void CSystem::SetOcclusionType(CObject& object, EOcclusionType const occlusionType) const
3655 {
3656 switch (occlusionType)
3657 {
3658 case EOcclusionType::Ignore:
3659 {
3660 object.HandleSetOcclusionType(EOcclusionType::Ignore);
3661 object.SetOcclusion(0.0f);
3662
3663 break;
3664 }
3665 case EOcclusionType::Adaptive:
3666 {
3667 object.HandleSetOcclusionType(EOcclusionType::Adaptive);
3668
3669 break;
3670 }
3671 case EOcclusionType::Low:
3672 {
3673 object.HandleSetOcclusionType(EOcclusionType::Low);
3674
3675 break;
3676 }
3677 case EOcclusionType::Medium:
3678 {
3679 object.HandleSetOcclusionType(EOcclusionType::Medium);
3680
3681 break;
3682 }
3683 case EOcclusionType::High:
3684 {
3685 object.HandleSetOcclusionType(EOcclusionType::High);
3686
3687 break;
3688 }
3689 default:
3690 {
3691 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3692 Cry::Audio::Log(ELogType::Warning, "Unknown occlusion type during %s: %u", __FUNCTION__, occlusionType);
3693 #endif // CRY_AUDIO_USE_DEBUG_CODE
3694
3695 break;
3696 }
3697 }
3698 }
3699 #endif // CRY_AUDIO_USE_OCCLUSION
3700
3701 //////////////////////////////////////////////////////////////////////////
3702 void CSystem::OnCallback(SRequestInfo const* const pRequestInfo)
3703 {
3704 if ((gEnv->mMainThreadId == CryGetCurrentThreadId()) && (pRequestInfo->entityId != INVALID_ENTITYID))
3705 {
3706 IEntity* const pIEntity = gEnv->pEntitySystem->GetEntity(pRequestInfo->entityId);
3707
3708 if (pIEntity != nullptr)
3709 {
3710 SEntityEvent eventData;
3711 eventData.nParam[0] = reinterpret_cast<intptr_t>(pRequestInfo);
3712
3713 if (pRequestInfo->systemEvent == ESystemEvents::TriggerExecuted)
3714 {
3715 eventData.event = ENTITY_EVENT_AUDIO_TRIGGER_STARTED;
3716 pIEntity->SendEvent(eventData);
3717 }
3718
3719 if ((pRequestInfo->systemEvent == ESystemEvents::TriggerFinished) ||
3720 ((pRequestInfo->systemEvent == ESystemEvents::TriggerExecuted) && (pRequestInfo->requestResult != ERequestResult::Success)))
3721 {
3722 eventData.event = ENTITY_EVENT_AUDIO_TRIGGER_ENDED;
3723 pIEntity->SendEvent(eventData);
3724 }
3725 }
3726 }
3727 }
3728
3729 //////////////////////////////////////////////////////////////////////////
3730 void CSystem::GetImplInfo(SImplInfo& implInfo)
3731 {
3732 SSystemRequestData<ESystemRequestType::GetImplInfo> const requestData(implInfo);
3733 CRequest const request(&requestData, ERequestFlags::ExecuteBlocking);
3734 PushRequest(request);
3735 }
3736
3737 #if defined(CRY_AUDIO_USE_DEBUG_CODE)
3738 //////////////////////////////////////////////////////////////////////////
3739 void CSystem::HandleRefresh()
3740 {
3741 Cry::Audio::Log(ELogType::Warning, "Beginning to refresh the AudioSystem!");
3742
3743 g_pIImpl->StopAllSounds();
3744
3745 for (auto const& contextPair : g_contextInfo)
3746 {
3747 if (contextPair.second.isRegistered && contextPair.second.isActive)
3748 {
3749 g_fileCacheManager.UnloadDataByContext(contextPair.second.contextId);
3750 }
3751 }
3752
3753 g_fileCacheManager.UnloadDataByContext(GlobalContextId);
3754
3755 // Store active contexts for reloading after they have been unloaded which empties the map.
3756 ContextInfo const tempContextInfo = g_contextInfo;
3757
3758 g_xmlProcessor.ClearPreloadsData(GlobalContextId, true);
3759 g_xmlProcessor.ClearControlsData(GlobalContextId, true);
3760 ReportContextDeactivated(GlobalContextId);
3761 ResetRequestCount();
3762
3763 g_pIImpl->OnRefresh();
3764
3765 g_xmlProcessor.ParseSystemData();
3766 g_xmlProcessor.ParseControlsData(g_configPath.c_str(), GlobalContextId, g_szGlobalContextName);
3767 g_xmlProcessor.ParsePreloadsData(g_configPath.c_str(), GlobalContextId);
3768
3769 // The global preload might not exist if no preloads have been created, for that reason we don't check the result of this call
3770 g_fileCacheManager.TryLoadRequest(GlobalPreloadRequestId, true, true);
3771
3772 AutoLoadSetting(GlobalContextId);
3773
3774 for (auto const& contextPair : tempContextInfo)
3775 {
3776 ContextId const contextId = contextPair.second.contextId;
3777
3778 if (contextPair.second.isRegistered && contextPair.second.isActive && (contextId != GlobalContextId))
3779 {
3780 char const* const szContextName = contextPair.first.c_str();
3781
3782 CryFixedStringT<MaxFilePathLength> contextPath = g_configPath;
3783 contextPath += g_szContextsFolderName;
3784 contextPath += "/";
3785 contextPath += szContextName;
3786
3787 g_xmlProcessor.ParseControlsData(contextPath.c_str(), contextId, szContextName);
3788 g_xmlProcessor.ParsePreloadsData(contextPath.c_str(), contextId);
3789
3790 auto const preloadRequestId = static_cast<PreloadRequestId>(contextId);
3791
3792 if (g_fileCacheManager.TryLoadRequest(preloadRequestId, true, true) != ERequestStatus::Success)
3793 {
3794 Cry::Audio::Log(ELogType::Warning, R"(No preload request found for context - "%s"!)", szContextName);
3795 }
3796
3797 AutoLoadSetting(contextId);
3798 ReportContextActivated(contextId);
3799 }
3800 }
3801
3802 HandleUpdateDebugInfo(EDebugUpdateFilter::FileCacheManager | EDebugUpdateFilter::Contexts);
3803
3804 Cry::Audio::Log(ELogType::Warning, "Done refreshing the AudioSystem!");
3805 }
3806
3807 //////////////////////////////////////////////////////////////////////////
3808 void CSystem::ScheduleIRenderAuxGeomForRendering(IRenderAuxGeom* pRenderAuxGeom)
3809 {
3810 auto oldRenderAuxGeom = m_currentRenderAuxGeom.exchange(pRenderAuxGeom);
3811 CRY_ASSERT(oldRenderAuxGeom != pRenderAuxGeom);
3812
3813 // Kill FIFO entries beyond 1, only the head survives in m_currentRenderAuxGeom
3814 // Throw away all older entries
3815 if (oldRenderAuxGeom && oldRenderAuxGeom != pRenderAuxGeom)
3816 {
3817 gEnv->pRenderer->DeleteAuxGeom(oldRenderAuxGeom);
3818 }
3819 }
3820
3821 //////////////////////////////////////////////////////////////////////////
3822 void CSystem::SubmitLastIRenderAuxGeomForRendering()
3823 {
3824 if (m_lastDebugRenderSubmitExternalFrame != gEnv->nMainFrameID)
3825 {
3826 // get auxGeom from "storage"
3827 auto pCurrentRenderAuxGeom = m_currentRenderAuxGeom.exchange(nullptr);
3828 if (pCurrentRenderAuxGeom != nullptr)
3829 {
3830 gEnv->pRenderer->SubmitAuxGeom(pCurrentRenderAuxGeom, true);
3831 // if another auxGeom was stored in the meantime, we can throw away the current one
3832 // otherwise we keep it around for re-use, to avoid flickering
3833 IRenderAuxGeom* pExpected = nullptr;
3834 if (!m_currentRenderAuxGeom.compare_exchange_strong(pExpected, pCurrentRenderAuxGeom))
3835 {
3836 gEnv->pRenderer->DeleteAuxGeom(pCurrentRenderAuxGeom);
3837 }
3838 m_lastDebugRenderSubmitExternalFrame = gEnv->nMainFrameID;
3839 }
3840 }
3841 }
3842
3843 //////////////////////////////////////////////////////////////////////////
3844 void CSystem::DrawDebug()
3845 {
3846 if (g_cvars.m_drawDebug > 0)
3847 {
3848 SubmitLastIRenderAuxGeomForRendering();
3849
3850 if (m_canDraw)
3851 {
3852 m_canDraw = false;
3853
3854 SSystemRequestData<ESystemRequestType::DrawDebugInfo> const requestData;
3855 CRequest const request(&requestData);
3856 PushRequest(request);
3857 }
3858 }
3859 }
3860
3861 //////////////////////////////////////////////////////////////////////////
3862 void CSystem::UpdateDebugInfo()
3863 {
3864 SSystemRequestData<ESystemRequestType::UpdateDebugInfo> const requestData;
3865 CRequest const request(&requestData);
3866 PushRequest(request);
3867 }
3868
3869 //////////////////////////////////////////////////////////////////////////
3870 void DrawRequestCategoryInfo(IRenderAuxGeom& auxGeom, float const posX, float& posY, char const* const szType)
3871 {
3872 auxGeom.Draw2dLabel(posX, posY, Debug::g_systemFontSize, Debug::s_systemColorTextSecondary, false, "%s Request Peak:", szType);
3873 posY += Debug::g_systemLineHeight;
3874 }
3875
3876 //////////////////////////////////////////////////////////////////////////
3877 void DrawRequestPeakInfo(IRenderAuxGeom& auxGeom, float const posX, float& posY, char const* const szType, uint16 const peak, uint16 poolSize)
3878 {
3879 bool const poolSizeExceeded = (peak > poolSize) && (poolSize != 0);
3880 CryFixedStringT<MaxInfoStringLength> debugText;
3881
3882 if (poolSizeExceeded)
3883 {
3884 debugText.Format("%s: %u (Pool Size: %u)", szType, peak, poolSize);
3885 }
3886 else
3887 {
3888 debugText.Format("%s: %u", szType, peak);
3889 }
3890
3891 auxGeom.Draw2dLabel(
3892 posX,
3893 posY,
3894 Debug::g_systemFontSize,
3895 poolSizeExceeded ? Debug::s_globalColorError : Debug::s_systemColorTextPrimary,
3896 false,
3897 "%s", debugText.c_str());
3898 posY += Debug::g_systemLineHeight;
3899 }
3900
3901 //////////////////////////////////////////////////////////////////////////
3902 void DrawRequestDebugInfo(IRenderAuxGeom& auxGeom, float const posX, float posY)
3903 {
3904 auxGeom.Draw2dLabel(posX, posY, Debug::g_listHeaderFontSize, Debug::s_globalColorHeader, false, "Audio Requests");
3905 posY += Debug::g_listHeaderLineHeight;
3906
3907 DrawRequestPeakInfo(auxGeom, posX, posY, "Total", g_requestPeaks.requests, 0);
3908
3909 DrawRequestCategoryInfo(auxGeom, posX, posY, "System");
3910 DrawRequestPeakInfo(auxGeom, posX, posY, "ExecuteTrigger", g_requestPeaks.systemExecuteTrigger, g_systemExecuteTriggerPoolSize);
3911 DrawRequestPeakInfo(auxGeom, posX, posY, "ExecuteTriggerEx", g_requestPeaks.systemExecuteTriggerEx, g_systemExecuteTriggerExPoolSize);
3912 DrawRequestPeakInfo(auxGeom, posX, posY, "ExecuteTriggerWithCallbacks", g_requestPeaks.systemExecuteTriggerWithCallbacks, g_systemExecuteTriggerWithCallbacksPoolSize);
3913 DrawRequestPeakInfo(auxGeom, posX, posY, "StopTrigger", g_requestPeaks.systemStopTrigger, g_systemStopTriggerPoolSize);
3914 DrawRequestPeakInfo(auxGeom, posX, posY, "RegisterObject", g_requestPeaks.systemRegisterObject, g_systemRegisterObjectPoolSize);
3915 DrawRequestPeakInfo(auxGeom, posX, posY, "ReleaseObject", g_requestPeaks.systemReleaseObject, g_systemReleaseObjectPoolSize);
3916 DrawRequestPeakInfo(auxGeom, posX, posY, "SetParameter", g_requestPeaks.systemSetParameter, g_systemSetParameterPoolSize);
3917 DrawRequestPeakInfo(auxGeom, posX, posY, "SetSwitchState", g_requestPeaks.systemSetSwitchState, g_systemSetSwitchStatePoolSize);
3918
3919 DrawRequestCategoryInfo(auxGeom, posX, posY, "Object");
3920 DrawRequestPeakInfo(auxGeom, posX, posY, "ExecuteTrigger", g_requestPeaks.objectExecuteTrigger, g_objectExecuteTriggerPoolSize);
3921 DrawRequestPeakInfo(auxGeom, posX, posY, "ExecuteTriggerWithCallbacks", g_requestPeaks.objectExecuteTriggerWithCallbacks, g_objectExecuteTriggerWithCallbacksPoolSize);
3922 DrawRequestPeakInfo(auxGeom, posX, posY, "StopTrigger", g_requestPeaks.objectStopTrigger, g_objectStopTriggerPoolSize);
3923 DrawRequestPeakInfo(auxGeom, posX, posY, "SetTransformation", g_requestPeaks.objectSetTransformation, g_objectSetTransformationPoolSize);
3924 DrawRequestPeakInfo(auxGeom, posX, posY, "SetParameter", g_requestPeaks.objectSetParameter, g_objectSetParameterPoolSize);
3925 DrawRequestPeakInfo(auxGeom, posX, posY, "SetSwitchState", g_requestPeaks.objectSetSwitchState, g_objectSetSwitchStatePoolSize);
3926 DrawRequestPeakInfo(auxGeom, posX, posY, "SetCurrentEnvironments", g_requestPeaks.objectSetCurrentEnvironments, g_objectSetCurrentEnvironmentsPoolSize);
3927 DrawRequestPeakInfo(auxGeom, posX, posY, "SetEnvironment", g_requestPeaks.objectSetEnvironment, g_objectSetEnvironmentPoolSize);
3928 DrawRequestPeakInfo(auxGeom, posX, posY, "ProcessPhysicsRay", g_requestPeaks.objectProcessPhysicsRay, g_objectProcessPhysicsRayPoolSize);
3929
3930 DrawRequestCategoryInfo(auxGeom, posX, posY, "Listener");
3931 DrawRequestPeakInfo(auxGeom, posX, posY, "SetTransformation", g_requestPeaks.listenerSetTransformation, g_listenerSetTransformationPoolSize);
3932
3933 DrawRequestCategoryInfo(auxGeom, posX, posY, "Callback");
3934 DrawRequestPeakInfo(auxGeom, posX, posY, "ReportStartedTriggerConnectionInstance", g_requestPeaks.callbackReportStartedriggerConnectionInstance, g_callbackReportStartedTriggerConnectionInstancePoolSize);
3935 DrawRequestPeakInfo(auxGeom, posX, posY, "ReportFinishedTriggerConnectionInstance", g_requestPeaks.callbackReportFinishedTriggerConnectionInstance, g_callbackReportFinishedTriggerConnectionInstancePoolSize);
3936 DrawRequestPeakInfo(auxGeom, posX, posY, "ReportFinishedTriggerInstance", g_requestPeaks.callbackReportFinishedTriggerInstance, g_callbackReportFinishedTriggerInstancePoolSize);
3937 DrawRequestPeakInfo(auxGeom, posX, posY, "ReportTriggerConnectionInstanceCallback", g_requestPeaks.callbackReportTriggerConnectionInstanceCallback, g_callbackReportTriggerConnectionInstanceCallbackPoolSize);
3938 DrawRequestPeakInfo(auxGeom, posX, posY, "SendTriggerInstanceCallback", g_requestPeaks.callbackSendTriggerInstanceCallback, g_callbackSendTriggerInstanceCallbackPoolSize);
3939 DrawRequestPeakInfo(auxGeom, posX, posY, "ReportPhysicalizedObject", g_requestPeaks.callbackReportPhysicalizedObject, g_callbackReportPhysicalizedObjectPoolSize);
3940 DrawRequestPeakInfo(auxGeom, posX, posY, "ReportVirtualizedObject", g_requestPeaks.callbackReportVirtualizedObject, g_callbackReportVirtualizedObjectPoolSize);
3941 }
3942
3943 //////////////////////////////////////////////////////////////////////////
3944 void DrawObjectInfo(
3945 IRenderAuxGeom& auxGeom,
3946 float const posX,
3947 float& posY,
3948 Vec3 const& camPos,
3949 CObject const& object,
3950 CryFixedStringT<MaxControlNameLength> const& lowerCaseSearchString,
3951 size_t& numObjects)
3952 {
3953 Vec3 const& position = object.GetTransformation().GetPosition();
3954 float const distance = position.GetDistance(camPos);
3955
3956 if ((g_cvars.m_debugDistance <= 0.0f) || ((g_cvars.m_debugDistance > 0.0f) && (distance < g_cvars.m_debugDistance)))
3957 {
3958 char const* const szObjectName = object.GetName();
3959 CryFixedStringT<MaxControlNameLength> lowerCaseObjectName(szObjectName);
3960 lowerCaseObjectName.MakeLower();
3961 bool const hasActiveData = (object.GetFlags() & EObjectFlags::Active) != EObjectFlags::None;
3962 bool const isVirtual = (object.GetFlags() & EObjectFlags::Virtual) != EObjectFlags::None;
3963 bool const stringFound = (lowerCaseSearchString.empty() || (lowerCaseSearchString.compareNoCase("0") == 0)) || (lowerCaseObjectName.find(lowerCaseSearchString) != CryFixedStringT<MaxControlNameLength>::npos);
3964 bool const draw = stringFound && ((g_cvars.m_hideInactiveObjects == 0) || ((g_cvars.m_hideInactiveObjects != 0) && hasActiveData && !isVirtual));
3965
3966 if (draw)
3967 {
3968 CryFixedStringT<MaxMiscStringLength> debugText;
3969
3970 if ((object.GetFlags() & EObjectFlags::InUse) != EObjectFlags::None)
3971 {
3972 debugText.Format(szObjectName);
3973 }
3974 else
3975 {
3976 debugText.Format("%s [To Be Released]", szObjectName);
3977 }
3978
3979 auxGeom.Draw2dLabel(
3980 posX,
3981 posY,
3982 Debug::g_listFontSize,
3983 !hasActiveData ? Debug::s_globalColorInactive : (isVirtual ? Debug::s_globalColorVirtual : Debug::s_listColorItemActive),
3984 false,
3985 "%s", debugText.c_str());
3986
3987 posY += Debug::g_listLineHeight;
3988 ++numObjects;
3989 }
3990 }
3991 }
3992
3993 //////////////////////////////////////////////////////////////////////////
3994 void DrawObjectDebugInfo(IRenderAuxGeom& auxGeom, float const posX, float posY)
3995 {
3996 size_t numObjects = 0;
3997 float const headerPosY = posY;
3998 CryFixedStringT<MaxControlNameLength> lowerCaseSearchString(g_cvars.m_pDebugFilter->GetString());
3999 lowerCaseSearchString.MakeLower();
4000
4001 posY += Debug::g_listHeaderLineHeight;
4002 Vec3 const& camPos = GetISystem()->GetViewCamera().GetPosition();
4003
4004 DrawObjectInfo(auxGeom, posX, posY, camPos, g_previewObject, lowerCaseSearchString, numObjects);
4005
4006 for (auto const pObject : g_constructedObjects)
4007 {
4008 float const distance = pObject->GetTransformation().GetPosition().GetDistance(camPos);
4009
4010 if ((g_cvars.m_debugDistance <= 0.0f) || ((g_cvars.m_debugDistance > 0.0f) && (distance <= g_cvars.m_debugDistance)))
4011 {
4012 DrawObjectInfo(auxGeom, posX, posY, camPos, *pObject, lowerCaseSearchString, numObjects);
4013 }
4014 }
4015
4016 auxGeom.Draw2dLabel(posX, headerPosY, Debug::g_listHeaderFontSize, Debug::s_globalColorHeader, false, "Audio Objects [%" PRISIZE_T "]", numObjects);
4017 }
4018
4019 //////////////////////////////////////////////////////////////////////////
4020 void DrawPerActiveObjectDebugInfo(IRenderAuxGeom& auxGeom)
4021 {
4022 CryFixedStringT<MaxControlNameLength> lowerCaseSearchString(g_cvars.m_pDebugFilter->GetString());
4023 lowerCaseSearchString.MakeLower();
4024 bool const isTextFilterDisabled = (lowerCaseSearchString.empty() || (lowerCaseSearchString.compareNoCase("0") == 0));
4025
4026 for (auto const pObject : g_activeObjects)
4027 {
4028 if ((pObject->GetFlags() & EObjectFlags::IgnoreDrawDebugInfo) == EObjectFlags::None)
4029 {
4030 pObject->DrawDebugInfo(auxGeom, isTextFilterDisabled, lowerCaseSearchString);
4031 }
4032 }
4033 }
4034
4035 //////////////////////////////////////////////////////////////////////////
4036 void DrawContextDebugInfo(IRenderAuxGeom& auxGeom, float const posX, float posY)
4037 {
4038 auxGeom.Draw2dLabel(posX, posY, Debug::g_listHeaderFontSize, Debug::s_globalColorHeader, false, "Contexts [%" PRISIZE_T "]", g_contextLookup.size() + 1);
4039 posY += Debug::g_listHeaderLineHeight;
4040
4041 for (auto const& contextPair : g_contextDebugInfo)
4042 {
4043 auxGeom.Draw2dLabel(
4044 posX,
4045 posY,
4046 Debug::g_listFontSize,
4047 contextPair.second ? Debug::s_listColorItemActive : Debug::s_globalColorInactive,
4048 false,
4049 "%s", contextPair.first.c_str());
4050
4051 posY += Debug::g_listLineHeight;
4052 }
4053 }
4054
4055 ///////////////////////////////////////////////////////////////////////////
4056 void DrawGlobalDataDebugInfo(IRenderAuxGeom& auxGeom, float const posX, float posY)
4057 {
4058 auxGeom.Draw2dLabel(posX, posY, Debug::g_listHeaderFontSize, Debug::s_globalColorHeader, false, g_szGlobalName);
4059 posY += Debug::g_listHeaderLineHeight;
4060
4061 // Check if text filter is enabled.
4062 CryFixedStringT<MaxControlNameLength> lowerCaseSearchString(g_cvars.m_pDebugFilter->GetString());
4063 lowerCaseSearchString.MakeLower();
4064 bool const isTextFilterDisabled = (lowerCaseSearchString.empty() || (lowerCaseSearchString.compareNoCase("0") == 0));
4065 bool const filterAllObjectInfo = (g_cvars.m_drawDebug & Debug::EDrawFilter::FilterAllObjectInfo) != 0;
4066
4067 // Check if any trigger matches text filter.
4068 bool doesTriggerMatchFilter = false;
4069 std::vector<CryFixedStringT<MaxMiscStringLength>> triggerInfo;
4070
4071 if (!g_triggerInstances.empty() || filterAllObjectInfo)
4072 {
4073 Debug::TriggerCounts triggerCounts;
4074
4075 for (auto const& triggerInstancePair : g_triggerInstances)
4076 {
4077 ++(triggerCounts[triggerInstancePair.second->GetTriggerId()]);
4078 }
4079
4080 for (auto const& triggerCountsPair : triggerCounts)
4081 {
4082 CTrigger const* const pTrigger = stl::find_in_map(g_triggerLookup, triggerCountsPair.first, nullptr);
4083
4084 if (pTrigger != nullptr)
4085 {
4086 char const* const szTriggerName = pTrigger->GetName();
4087
4088 if (!isTextFilterDisabled)
4089 {
4090 CryFixedStringT<MaxControlNameLength> lowerCaseTriggerName(szTriggerName);
4091 lowerCaseTriggerName.MakeLower();
4092
4093 if (lowerCaseTriggerName.find(lowerCaseSearchString) != CryFixedStringT<MaxControlNameLength>::npos)
4094 {
4095 doesTriggerMatchFilter = true;
4096 }
4097 }
4098
4099 CryFixedStringT<MaxMiscStringLength> debugText;
4100 uint8 const numInstances = triggerCountsPair.second;
4101
4102 if (numInstances == 1)
4103 {
4104 debugText.Format("%s\n", szTriggerName);
4105 }
4106 else
4107 {
4108 debugText.Format("%s: %u\n", szTriggerName, numInstances);
4109 }
4110
4111 triggerInfo.emplace_back(debugText);
4112 }
4113 }
4114 }
4115
4116 // Check if any state or switch matches text filter.
4117 bool doesStateSwitchMatchFilter = false;
4118 std::map<CSwitch const* const, CSwitchState const* const> switchStateInfo;
4119
4120 if (!g_switchStates.empty() || filterAllObjectInfo)
4121 {
4122 for (auto const& switchStatePair : g_switchStates)
4123 {
4124 CSwitch const* const pSwitch = stl::find_in_map(g_switchLookup, switchStatePair.first, nullptr);
4125
4126 if (pSwitch != nullptr)
4127 {
4128 CSwitchState const* const pSwitchState = stl::find_in_map(pSwitch->GetStates(), switchStatePair.second, nullptr);
4129
4130 if (pSwitchState != nullptr)
4131 {
4132 if (!isTextFilterDisabled)
4133 {
4134 char const* const szSwitchName = pSwitch->GetName();
4135 CryFixedStringT<MaxControlNameLength> lowerCaseSwitchName(szSwitchName);
4136 lowerCaseSwitchName.MakeLower();
4137 char const* const szStateName = pSwitchState->GetName();
4138 CryFixedStringT<MaxControlNameLength> lowerCaseStateName(szStateName);
4139 lowerCaseStateName.MakeLower();
4140
4141 if ((lowerCaseSwitchName.find(lowerCaseSearchString) != CryFixedStringT<MaxControlNameLength>::npos) ||
4142 (lowerCaseStateName.find(lowerCaseSearchString) != CryFixedStringT<MaxControlNameLength>::npos))
4143 {
4144 doesStateSwitchMatchFilter = true;
4145 }
4146 }
4147
4148 switchStateInfo.emplace(pSwitch, pSwitchState);
4149 }
4150 }
4151 }
4152 }
4153
4154 // Check if any parameter matches text filter.
4155 bool doesParameterMatchFilter = false;
4156 std::map<char const* const, float const> parameterInfo;
4157
4158 if (!g_parameters.empty() || filterAllObjectInfo)
4159 {
4160 for (auto const& parameterPair : g_parameters)
4161 {
4162 CParameter const* const pParameter = stl::find_in_map(g_parameterLookup, parameterPair.first, nullptr);
4163
4164 if (pParameter != nullptr)
4165 {
4166 char const* const szParameterName = pParameter->GetName();
4167
4168 if (!isTextFilterDisabled)
4169 {
4170 CryFixedStringT<MaxControlNameLength> lowerCaseParameterName(szParameterName);
4171 lowerCaseParameterName.MakeLower();
4172
4173 if (lowerCaseParameterName.find(lowerCaseSearchString) != CryFixedStringT<MaxControlNameLength>::npos)
4174 {
4175 doesParameterMatchFilter = true;
4176 }
4177 }
4178
4179 parameterInfo.emplace(szParameterName, parameterPair.second);
4180 }
4181 }
4182 }
4183
4184 if (isTextFilterDisabled || doesTriggerMatchFilter)
4185 {
4186 for (auto const& debugText : triggerInfo)
4187 {
4188 auxGeom.Draw2dLabel(
4189 posX,
4190 posY,
4191 Debug::g_objectFontSize,
4192 Debug::s_objectColorTrigger,
4193 false,
4194 "%s", debugText.c_str());
4195
4196 posY += Debug::g_objectLineHeight;
4197 }
4198 }
4199
4200 if (isTextFilterDisabled || doesStateSwitchMatchFilter)
4201 {
4202 for (auto const& switchStatePair : switchStateInfo)
4203 {
4204 auto const pSwitch = switchStatePair.first;
4205 auto const pSwitchState = switchStatePair.second;
4206
4207 Debug::CStateDrawData& drawData = g_stateDrawInfo.emplace(std::piecewise_construct, std::forward_as_tuple(pSwitch->GetId()), std::forward_as_tuple(pSwitchState->GetId())).first->second;
4208 drawData.Update(pSwitchState->GetId());
4209 ColorF const switchTextColor = { 0.8f, drawData.m_currentSwitchColor, 0.6f };
4210
4211 auxGeom.Draw2dLabel(
4212 posX,
4213 posY,
4214 Debug::g_objectFontSize,
4215 switchTextColor,
4216 false,
4217 "%s: %s\n",
4218 pSwitch->GetName(),
4219 pSwitchState->GetName());
4220
4221 posY += Debug::g_objectLineHeight;
4222 }
4223 }
4224
4225 if (isTextFilterDisabled || doesParameterMatchFilter)
4226 {
4227 for (auto const& parameterPair : parameterInfo)
4228 {
4229 auxGeom.Draw2dLabel(
4230 posX,
4231 posY,
4232 Debug::g_objectFontSize,
4233 Debug::s_objectColorParameter,
4234 false,
4235 "%s: %2.2f\n",
4236 parameterPair.first,
4237 parameterPair.second);
4238
4239 posY += Debug::g_objectLineHeight;
4240 }
4241 }
4242
4243 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ObjectImplInfo) != 0)
4244 {
4245 g_pIObject->DrawDebugInfo(auxGeom, posX, posY, (isTextFilterDisabled ? nullptr : lowerCaseSearchString.c_str()));
4246 }
4247 }
4248
4249 //////////////////////////////////////////////////////////////////////////
4250 void CSystem::HandleDrawDebug()
4251 {
4252 CRY_PROFILE_FUNCTION(PROFILE_AUDIO);
4253 IRenderAuxGeom* const pAuxGeom = gEnv->pRenderer ? gEnv->pRenderer->GetOrCreateIRenderAuxGeom() : nullptr;
4254
4255 if (pAuxGeom != nullptr)
4256 {
4257 if ((g_cvars.m_drawDebug & Debug::objectMask) != 0)
4258 {
4259 // Needs to be called first so that the rest of the labels are printed on top.
4260 // (Draw2dLabel doesn't provide a way to set which labels are printed on top)
4261 DrawPerActiveObjectDebugInfo(*pAuxGeom);
4262 }
4263
4264 float posX = 8.0f;
4265 float posY = 4.0f;
4266 float const headerPosY = posY;
4267
4268 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::HideMemoryInfo) == 0)
4269 {
4270 posY += Debug::g_systemHeaderLineSpacerHeight;
4271
4272 size_t totalPoolSize = 0;
4273 bool const drawDetailedMemInfo = (g_cvars.m_drawDebug & Debug::EDrawFilter::DetailedMemoryInfo) != 0;
4274
4275 {
4276 auto& allocator = CObject::GetAllocator();
4277 size_t const memAlloc = allocator.GetTotalMemory().nAlloc;
4278 totalPoolSize += memAlloc;
4279
4280 if (drawDetailedMemInfo)
4281 {
4282 Debug::DrawMemoryPoolInfo(*pAuxGeom, posX, posY, memAlloc, allocator.GetCounts(), "Objects", m_objectPoolSize);
4283 }
4284 }
4285
4286 #if defined(CRY_AUDIO_USE_OCCLUSION)
4287 {
4288 auto& allocator = SOcclusionInfo::GetAllocator();
4289 size_t const memAlloc = allocator.GetTotalMemory().nAlloc;
4290 totalPoolSize += memAlloc;
4291
4292 if (drawDetailedMemInfo)
4293 {
4294 Debug::DrawMemoryPoolInfo(*pAuxGeom, posX, posY, memAlloc, allocator.GetCounts(), "Occlusion Infos", m_objectPoolSize);
4295 }
4296 }
4297 #endif // CRY_AUDIO_USE_OCCLUSION
4298
4299 {
4300 auto& allocator = CTriggerInstance::GetAllocator();
4301 size_t const memAlloc = allocator.GetTotalMemory().nAlloc;
4302 totalPoolSize += memAlloc;
4303
4304 if (drawDetailedMemInfo)
4305 {
4306 Debug::DrawMemoryPoolInfo(*pAuxGeom, posX, posY, memAlloc, allocator.GetCounts(), "Trigger Instances", static_cast<uint16>(g_cvars.m_triggerInstancePoolSize));
4307 }
4308 }
4309
4310 if (g_debugPoolSizes.triggers > 0)
4311 {
4312 auto& allocator = CTrigger::GetAllocator();
4313 size_t const memAlloc = allocator.GetTotalMemory().nAlloc;
4314 totalPoolSize += memAlloc;
4315
4316 if (drawDetailedMemInfo)
4317 {
4318 Debug::DrawMemoryPoolInfo(*pAuxGeom, posX, posY, memAlloc, allocator.GetCounts(), "Triggers", g_poolSizes.triggers);
4319 }
4320 }
4321
4322 if (g_debugPoolSizes.parameters > 0)
4323 {
4324 auto& allocator = CParameter::GetAllocator();
4325 size_t const memAlloc = allocator.GetTotalMemory().nAlloc;
4326 totalPoolSize += memAlloc;
4327
4328 if (drawDetailedMemInfo)
4329 {
4330 Debug::DrawMemoryPoolInfo(*pAuxGeom, posX, posY, memAlloc, allocator.GetCounts(), "Parameters", g_poolSizes.parameters);
4331 }
4332 }
4333
4334 if (g_debugPoolSizes.switches > 0)
4335 {
4336 auto& allocator = CSwitch::GetAllocator();
4337 size_t const memAlloc = allocator.GetTotalMemory().nAlloc;
4338 totalPoolSize += memAlloc;
4339
4340 if (drawDetailedMemInfo)
4341 {
4342 Debug::DrawMemoryPoolInfo(*pAuxGeom, posX, posY, memAlloc, allocator.GetCounts(), "Switches", g_poolSizes.switches);
4343 }
4344 }
4345
4346 if (g_debugPoolSizes.states > 0)
4347 {
4348 auto& allocator = CSwitchState::GetAllocator();
4349 size_t const memAlloc = allocator.GetTotalMemory().nAlloc;
4350 totalPoolSize += memAlloc;
4351
4352 if (drawDetailedMemInfo)
4353 {
4354 Debug::DrawMemoryPoolInfo(*pAuxGeom, posX, posY, memAlloc, allocator.GetCounts(), "SwitchStates", g_poolSizes.states);
4355 }
4356 }
4357
4358 if (g_debugPoolSizes.environments > 0)
4359 {
4360 auto& allocator = CEnvironment::GetAllocator();
4361 size_t const memAlloc = allocator.GetTotalMemory().nAlloc;
4362 totalPoolSize += memAlloc;
4363
4364 if (drawDetailedMemInfo)
4365 {
4366 Debug::DrawMemoryPoolInfo(*pAuxGeom, posX, posY, memAlloc, allocator.GetCounts(), "Environments", g_poolSizes.environments);
4367 }
4368 }
4369
4370 if (g_debugPoolSizes.preloads > 0)
4371 {
4372 auto& allocator = CPreloadRequest::GetAllocator();
4373 size_t const memAlloc = allocator.GetTotalMemory().nAlloc;
4374 totalPoolSize += memAlloc;
4375
4376 if (drawDetailedMemInfo)
4377 {
4378 Debug::DrawMemoryPoolInfo(*pAuxGeom, posX, posY, memAlloc, allocator.GetCounts(), "Preloads", g_poolSizes.preloads);
4379 }
4380 }
4381
4382 if (g_debugPoolSizes.settings > 0)
4383 {
4384 auto& allocator = CSetting::GetAllocator();
4385 size_t const memAlloc = allocator.GetTotalMemory().nAlloc;
4386 totalPoolSize += memAlloc;
4387
4388 if (drawDetailedMemInfo)
4389 {
4390 Debug::DrawMemoryPoolInfo(*pAuxGeom, posX, posY, memAlloc, allocator.GetCounts(), "Settings", g_poolSizes.settings);
4391 }
4392 }
4393
4394 if (g_debugPoolSizes.files > 0)
4395 {
4396 auto& allocator = CFile::GetAllocator();
4397 size_t const memAlloc = allocator.GetTotalMemory().nAlloc;
4398 totalPoolSize += memAlloc;
4399
4400 if (drawDetailedMemInfo)
4401 {
4402 Debug::DrawMemoryPoolInfo(*pAuxGeom, posX, posY, memAlloc, allocator.GetCounts(), "Files", g_poolSizes.files);
4403 }
4404 }
4405
4406 CryModuleMemoryInfo memInfo;
4407 ZeroStruct(memInfo);
4408
4409 #if !defined(_LIB)
4410 // This works differently in monolithic builds and therefore doesn't cater to our needs.
4411 CryGetMemoryInfoForModule(&memInfo);
4412 #endif // _LIB
4413
4414 CryFixedStringT<Debug::MaxMemInfoStringLength> memAllocSizeString;
4415 auto const memAllocSize = static_cast<size_t>(memInfo.allocated - memInfo.freed);
4416 Debug::FormatMemoryString(memAllocSizeString, memAllocSize);
4417
4418 CryFixedStringT<Debug::MaxMemInfoStringLength> totalPoolSizeString;
4419 Debug::FormatMemoryString(totalPoolSizeString, totalPoolSize);
4420
4421 size_t const totalFileSize = g_fileCacheManager.GetTotalCachedFileSize();
4422
4423 CryFixedStringT<Debug::MaxMemInfoStringLength> totalMemSizeString;
4424 size_t const totalMemSize = memAllocSize + totalPoolSize + totalFileSize;
4425 Debug::FormatMemoryString(totalMemSizeString, totalMemSize);
4426
4427 char const* const szMuted = ((g_systemStates& ESystemStates::IsMuted) != ESystemStates::None) ? " - Muted" : "";
4428 char const* const szPaused = ((g_systemStates& ESystemStates::IsPaused) != ESystemStates::None) ? " - Paused" : "";
4429
4430 if (totalFileSize > 0)
4431 {
4432 CryFixedStringT<Debug::MaxMemInfoStringLength> totalFileSizeString;
4433 Debug::FormatMemoryString(totalFileSizeString, totalFileSize);
4434
4435 pAuxGeom->Draw2dLabel(posX, headerPosY, Debug::g_systemHeaderFontSize, Debug::s_globalColorHeader, false,
4436 "Audio (System: %s | Pools: %s | Assets: %s | Total: %s)%s%s",
4437 memAllocSizeString.c_str(), totalPoolSizeString.c_str(), totalFileSizeString.c_str(), totalMemSizeString.c_str(), szMuted, szPaused);
4438 }
4439 else
4440 {
4441 pAuxGeom->Draw2dLabel(posX, headerPosY, Debug::g_systemHeaderFontSize, Debug::s_globalColorHeader, false,
4442 "Audio (System: %s | Pools: %s | Total: %s)%s%s",
4443 memAllocSizeString.c_str(), totalPoolSizeString.c_str(), totalMemSizeString.c_str(), szMuted, szPaused);
4444 }
4445
4446 size_t const numObjects = g_constructedObjects.size();
4447 size_t const numActiveObjects = g_activeObjects.size();
4448 size_t const numListeners = g_listenerManager.GetNumListeners();
4449 size_t const numEventListeners = g_eventListenerManager.GetNumEventListeners();
4450
4451 #if defined(CRY_AUDIO_USE_OCCLUSION)
4452 static float const SMOOTHING_ALPHA = 0.2f;
4453 static float syncRays = 0;
4454 static float asyncRays = 0;
4455 syncRays += (CPropagationProcessor::s_totalSyncPhysRays - syncRays) * SMOOTHING_ALPHA;
4456 asyncRays += (CPropagationProcessor::s_totalAsyncPhysRays - asyncRays) * SMOOTHING_ALPHA * 0.1f;
4457
4458 posY += Debug::g_systemLineHeight;
4459 pAuxGeom->Draw2dLabel(posX, posY, Debug::g_systemFontSize, Debug::s_systemColorTextSecondary, false,
4460 "Objects: %3" PRISIZE_T "/%3" PRISIZE_T " | EventListeners %3" PRISIZE_T " | Listeners: %" PRISIZE_T " | SyncRays: %3.1f AsyncRays: %3.1f",
4461 numActiveObjects, numObjects, numEventListeners, numListeners, syncRays, asyncRays);
4462 #else
4463 posY += Debug::g_systemLineHeight;
4464 pAuxGeom->Draw2dLabel(posX, posY, Debug::g_systemFontSize, Debug::s_systemColorTextSecondary, false,
4465 "Objects: %3" PRISIZE_T "/%3" PRISIZE_T " | EventListeners %3" PRISIZE_T " | Listeners: %" PRISIZE_T,
4466 numActiveObjects, numObjects, numEventListeners, numListeners);
4467 #endif // CRY_AUDIO_USE_OCCLUSION
4468
4469 if (g_pIImpl != nullptr)
4470 {
4471 posY += Debug::g_systemHeaderLineHeight;
4472 g_pIImpl->DrawDebugMemoryInfo(*pAuxGeom, posX, posY, (g_cvars.m_drawDebug & Debug::EDrawFilter::DetailedMemoryInfo) != 0);
4473 }
4474
4475 posY += Debug::g_systemHeaderLineHeight;
4476 }
4477
4478 string debugFilter = g_cvars.m_pDebugFilter->GetString();
4479
4480 if (debugFilter.IsEmpty() || debugFilter == "0")
4481 {
4482 debugFilter = "<none>";
4483 }
4484
4485 string debugDistance = ToString(g_cvars.m_debugDistance) + " m";
4486
4487 if (g_cvars.m_debugDistance <= 0)
4488 {
4489 debugDistance = "<infinite>";
4490 }
4491
4492 string debugDraw = "";
4493
4494 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::Spheres) != 0)
4495 {
4496 debugDraw += "Spheres, ";
4497 }
4498
4499 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ObjectLabel) != 0)
4500 {
4501 debugDraw += "Labels, ";
4502 }
4503
4504 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ObjectTriggers) != 0)
4505 {
4506 debugDraw += "Triggers, ";
4507 }
4508
4509 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ObjectStates) != 0)
4510 {
4511 debugDraw += "States, ";
4512 }
4513
4514 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ObjectParameters) != 0)
4515 {
4516 debugDraw += "Parameters, ";
4517 }
4518
4519 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ObjectEnvironments) != 0)
4520 {
4521 debugDraw += "Environments, ";
4522 }
4523
4524 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ObjectDistance) != 0)
4525 {
4526 debugDraw += "Distances, ";
4527 }
4528
4529 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::OcclusionRayLabels) != 0)
4530 {
4531 debugDraw += "Occlusion Ray Labels, ";
4532 }
4533
4534 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::OcclusionRays) != 0)
4535 {
4536 debugDraw += "Occlusion Rays, ";
4537 }
4538
4539 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::OcclusionRayOffset) != 0)
4540 {
4541 debugDraw += "Occlusion Ray Offset, ";
4542 }
4543
4544 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::OcclusionListenerPlane) != 0)
4545 {
4546 debugDraw += "Occlusion Listener Plane, ";
4547 }
4548
4549 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::OcclusionCollisionSpheres) != 0)
4550 {
4551 debugDraw += "Occlusion Collision Spheres, ";
4552 }
4553
4554 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::GlobalPlaybackInfo) != 0)
4555 {
4556 debugDraw += "Default Object Info, ";
4557 }
4558
4559 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ObjectImplInfo) != 0)
4560 {
4561 debugDraw += "Object Middleware Info, ";
4562 }
4563
4564 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::Contexts) != 0)
4565 {
4566 debugDraw += "Active Contexts, ";
4567 }
4568
4569 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ImplList) != 0)
4570 {
4571 debugDraw += "Implementation List, ";
4572 }
4573
4574 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ActiveObjects) != 0)
4575 {
4576 debugDraw += "Active Objects, ";
4577 }
4578
4579 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::FileCacheManagerInfo) != 0)
4580 {
4581 debugDraw += "File Cache Manager, ";
4582 }
4583
4584 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::RequestInfo) != 0)
4585 {
4586 debugDraw += "Requests, ";
4587 }
4588
4589 if (!debugDraw.IsEmpty())
4590 {
4591 debugDraw.erase(debugDraw.length() - 2, 2);
4592 pAuxGeom->Draw2dLabel(posX, posY, Debug::g_systemFontSize, Debug::s_systemColorTextPrimary, false, "Debug Draw: %s", debugDraw.c_str());
4593 posY += Debug::g_systemLineHeight;
4594 pAuxGeom->Draw2dLabel(posX, posY, Debug::g_systemFontSize, Debug::s_systemColorTextPrimary, false, "Debug Filter: %s | Debug Distance: %s", debugFilter.c_str(), debugDistance.c_str());
4595
4596 posY += Debug::g_systemHeaderLineHeight;
4597 }
4598
4599 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::FileCacheManagerInfo) != 0)
4600 {
4601 g_fileCacheManager.DrawDebugInfo(*pAuxGeom, posX, posY);
4602 posX += 600.0f;
4603 }
4604
4605 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::GlobalPlaybackInfo) != 0)
4606 {
4607 DrawGlobalDataDebugInfo(*pAuxGeom, posX, posY);
4608 posX += 400.0f;
4609 }
4610
4611 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::Contexts) != 0)
4612 {
4613 DrawContextDebugInfo(*pAuxGeom, posX, posY);
4614 posX += 200.0f;
4615 }
4616
4617 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ActiveObjects) != 0)
4618 {
4619 DrawObjectDebugInfo(*pAuxGeom, posX, posY);
4620 posX += 300.0f;
4621 }
4622
4623 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::ImplList) != 0)
4624 {
4625 if (g_pIImpl != nullptr)
4626 {
4627 Vec3 const& camPos = GetISystem()->GetViewCamera().GetPosition();
4628
4629 g_pIImpl->DrawDebugInfoList(*pAuxGeom, posX, posY, camPos, g_cvars.m_debugDistance, g_cvars.m_pDebugFilter->GetString());
4630 // The impl is responsible for increasing posX.
4631 }
4632 }
4633
4634 if ((g_cvars.m_drawDebug & Debug::EDrawFilter::RequestInfo) != 0)
4635 {
4636 DrawRequestDebugInfo(*pAuxGeom, posX, posY);
4637 posX += 600.0f;
4638 }
4639 }
4640
4641 g_system.ScheduleIRenderAuxGeomForRendering(pAuxGeom);
4642 }
4643
4644 //////////////////////////////////////////////////////////////////////////
4645 void CSystem::HandleRetriggerControls()
4646 {
4647 for (auto const pObject : g_constructedObjects)
4648 {
4649 pObject->ForceImplementationRefresh();
4650 }
4651
4652 ForceGlobalDataImplRefresh();
4653 g_previewObject.ForceImplementationRefresh();
4654
4655 if ((g_systemStates& ESystemStates::IsMuted) != ESystemStates::None)
4656 {
4657 ExecuteDefaultTrigger(EDefaultTriggerType::MuteAll);
4658 }
4659
4660 if ((g_systemStates& ESystemStates::IsPaused) != ESystemStates::None)
4661 {
4662 ExecuteDefaultTrigger(EDefaultTriggerType::PauseAll);
4663 }
4664 }
4665 #endif // CRY_AUDIO_USE_DEBUG_CODE
4666 } // namespace CryAudio
CRYENGINE is a powerful real-time game development platform created by Crytek.