バージョン

menu_open
Wwise SDK 2024.1.1
AkKeyArray.h
[詳解]
1 /*******************************************************************************
2 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
3 released in source code form as part of the SDK installer package.
4 
5 Commercial License Usage
6 
7 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
8 may use this file in accordance with the end user license agreement provided
9 with the software or, alternatively, in accordance with the terms contained in a
10 written agreement between you and Audiokinetic Inc.
11 
12 Apache License Usage
13 
14 Alternatively, this file may be used under the Apache License, Version 2.0 (the
15 "Apache License"); you may not use this file except in compliance with the
16 Apache License. You may obtain a copy of the Apache License at
17 http://www.apache.org/licenses/LICENSE-2.0.
18 
19 Unless required by applicable law or agreed to in writing, software distributed
20 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
21 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
22 the specific language governing permissions and limitations under the License.
23 
24  Copyright (c) 2024 Audiokinetic Inc.
25 *******************************************************************************/
26 
27 #ifndef _KEYARRAY_H_
28 #define _KEYARRAY_H_
29 
32 
33 // The Key list is simply a list that may be referenced using a key
34 // NOTE :
35 template <class T_KEY, class T_ITEM, class U_POOL = ArrayPoolDefault, class TGrowBy = AkGrowByPolicy_DEFAULT, class TMovePolicy = AkAssignmentMovePolicy<MapStruct<T_KEY, T_ITEM> > >
36 class CAkKeyArray : public AkArray< MapStruct<T_KEY, T_ITEM>, const MapStruct<T_KEY, T_ITEM>&, U_POOL, TGrowBy, TMovePolicy>
37 {
38 public:
39  //====================================================================================================
40  // Return NULL if the Key does not exisis
41  // Return T_ITEM* otherwise
42  //====================================================================================================
43  T_ITEM* Exists(T_KEY in_Key) const
44  {
46  return (it != this->End()) ? &(it.pItem->item) : NULL;
47  }
48 
49 public:
50  //====================================================================================================
51  // Sets the item referenced by the specified key and item
52  // Return AK_Fail if the list max size was exceeded
53  //====================================================================================================
54  T_ITEM * Set(T_KEY in_Key, const T_ITEM & in_Item)
55  {
56  T_ITEM* pSearchedItem = Exists(in_Key);
57  if (pSearchedItem)
58  {
59  *pSearchedItem = in_Item;
60  }
61  else
62  {
63  MapStruct<T_KEY, T_ITEM> * pStruct = this->AddLast();
64  if (pStruct)
65  {
66  pStruct->key = in_Key;
67  pStruct->item = in_Item;
68  pSearchedItem = &(pStruct->item);
69  }
70  }
71  return pSearchedItem;
72  }
73 
74  T_ITEM * SetFirst(T_KEY in_Key, const T_ITEM & in_Item)
75  {
76  T_ITEM* pSearchedItem = Exists(in_Key);
77  if (pSearchedItem)
78  {
79  *pSearchedItem = in_Item;
80  }
81  else
82  {
83  MapStruct<T_KEY, T_ITEM> * pStruct = this->Insert(0); //insert at index 0 is AddFirst.
84  if (pStruct)
85  {
86  pStruct->key = in_Key;
87  pStruct->item = in_Item;
88  pSearchedItem = &(pStruct->item);
89  }
90  }
91  return pSearchedItem;
92  }
93 
94  T_ITEM * Set(T_KEY in_Key)
95  {
96  T_ITEM* pSearchedItem = Exists(in_Key);
97  if (!pSearchedItem)
98  {
99  MapStruct<T_KEY, T_ITEM> * pStruct = this->AddLast();
100  if (pStruct)
101  {
102  pStruct->key = in_Key;
103  pSearchedItem = &(pStruct->item);
104  }
105  }
106  return pSearchedItem;
107  }
108 
109  // NOTE: The real definition should be
110  // typename CAkKeyArray<T_KEY,T_ITEM,TGrowBy, TMovePolicy>::Iterator FindEx( T_KEY in_Item ) const
111  // Typenaming the base class is a workaround for bug MTWX33123 in the new Freescale CodeWarrior.
112  typename AkArray< MapStruct<T_KEY, T_ITEM>, const MapStruct<T_KEY, T_ITEM>&, U_POOL, TGrowBy, TMovePolicy>::Iterator FindEx(T_KEY in_Item) const
113  {
115 
117  for (; it != itEnd; ++it)
118  {
119  if ((*it).key == in_Item)
120  break;
121  }
122 
123  return it;
124  }
125 
126  //====================================================================================================
127  // Remove the item referenced by the specified key
128  //====================================================================================================
129 
130  void Unset(T_KEY in_Key)
131  {
133  if (it != this->End())
134  {
135  this->Erase(it);
136  }
137  }
138 
139  //====================================================================================================
140  // More efficient version of Unset when order is unimportant
141  //====================================================================================================
142 
143  void UnsetSwap(T_KEY in_Key)
144  {
146  if (it != this->End())
147  {
148  this->EraseSwap(it);
149  }
150  }
151 };
152 
153 /// Key policy for AkSortedKeyArray.
154 template <class T_KEY, class T_ITEM> struct AkGetArrayKey
155 {
156  /// Default policy.
157  static AkForceInline T_KEY & Get(T_ITEM & in_item)
158  {
159  return in_item.key;
160  }
161 };
162 
163 template <class T_KEY, class T_ITEM> struct AkGetArrayKeyFunc
164 {
165  /// Default policy.
166  static AkForceInline T_KEY& Get(T_ITEM& in_item)
167  {
168  return in_item.Key();
169  }
170 };
171 
172 /// Trivial key policy for AkSortedKeyArray, when T_KEY is T_ITEM.
174 {
175  /// Default policy.
176  template <class T_KEY>
177  static AkForceInline T_KEY& Get(T_KEY& in_item)
178  {
179  return in_item;
180  }
181 };
182 
183 //Default comparison policy for AkSortedKeyArray.
184 template <class T_KEY> struct AkDefaultSortedKeyCompare
185 {
186 public:
187  template<class THIS_CLASS>
188  static AkForceInline bool Lesser(THIS_CLASS*, const T_KEY &a, const T_KEY &b)
189  {
190  return a < b;
191  }
192 
193  template<class THIS_CLASS>
194  static AkForceInline bool Equal(THIS_CLASS*, const T_KEY &a, const T_KEY &b)
195  {
196  return a == b;
197  }
198 };
199 
200 /// Array of items, sorted by key. Uses binary search for lookups. BEWARE WHEN
201 /// MODIFYING THE ARRAY USING BASE CLASS METHODS.
202 template <class T_KEY, class T_ITEM, class U_POOL = ArrayPoolDefault, class U_KEY = AkGetArrayKey< T_KEY, T_ITEM >, class TGrowBy = AkGrowByPolicy_DEFAULT, class TMovePolicy = AkAssignmentMovePolicy<T_ITEM>, class TComparePolicy = AkDefaultSortedKeyCompare<T_KEY> >
203 class AkSortedKeyArray : public AkArray< T_ITEM, const T_ITEM &, U_POOL, TGrowBy, TMovePolicy >
204 {
205 public:
207  using Iterator = typename base::Iterator;
208 
209  AkForceInline bool Lesser(const T_KEY &a, const T_KEY &b) const
210  {
211  return TComparePolicy::Lesser((void*)this, a, b);
212  }
213 
214  AkForceInline bool Equal(const T_KEY &a, const T_KEY &b) const
215  {
216  return TComparePolicy::Equal((void*)this, a, b);
217  }
218 
219  AkUInt32 GetIndex(T_ITEM* in_pItem) const
220  {
221  if (this->m_pItems && this->m_uLength > 0)
222  {
223  AkUInt32 index = (AkUInt32)(in_pItem - this->m_pItems);
224  if ((this->m_pItems + index) == in_pItem)
225  return index;
226  }
227  return this->m_uLength;
228  }
229 
230  T_ITEM* Exists(T_KEY in_key) const
231  {
232  bool bFound;
233  T_ITEM* pItem = BinarySearch(in_key, bFound);
234  return bFound ? pItem : NULL;
235  }
236 
237  // Add an item to the list (allowing duplicate keys)
238 
239  T_ITEM * Add(T_KEY in_key)
240  {
241  T_ITEM * pItem = AddNoSetKey(in_key);
242 
243  // Then set the key
244  if (pItem)
245  U_KEY::Get(*pItem) = in_key;
246 
247  return pItem;
248  }
249 
250  // Add an item to the list (allowing duplicate keys)
251 
252  T_ITEM * AddNoSetKey(T_KEY in_key)
253  {
254  bool bFound;
255  return AddNoSetKey(in_key, bFound);
256  }
257 
258  T_ITEM * AddNoSetKey(T_KEY in_key, bool& out_bFound)
259  {
260  T_ITEM * pItem = BinarySearch(in_key, out_bFound);
261  if (pItem)
262  {
263  unsigned int uIdx = (unsigned int)(pItem - this->m_pItems);
264  pItem = this->Insert(uIdx);
265  }
266  else
267  {
268  pItem = this->AddLast();
269  }
270 
271  return pItem;
272  }
273 
274  // Set an item in the list (returning existing item if present)
275 
276  T_ITEM * Set(T_KEY in_key)
277  {
278  bool bFound;
279  return Set(in_key, bFound);
280  }
281 
282  T_ITEM * Set(T_KEY in_key, bool & out_bExists)
283  {
284  T_ITEM * pItem = BinarySearch(in_key, out_bExists);
285  if (!out_bExists)
286  {
287  if (pItem)
288  {
289  unsigned int uIdx = (unsigned int)(pItem - this->m_pItems);
290  pItem = this->Insert(uIdx);
291  }
292  else
293  {
294  pItem = this->AddLast();
295  }
296 
297  if (pItem)
298  U_KEY::Get(*pItem) = in_key;
299  }
300 
301  return pItem;
302  }
303 
304  bool Unset(T_KEY in_key)
305  {
306  T_ITEM * pItem = Exists(in_key);
307  if (pItem)
308  {
309  Iterator it;
310  it.pItem = pItem;
311  this->Erase(it);
312  return true;
313  }
314 
315  return false;
316  }
317 
318  // Replace current sorted items with a list of sorted updates.
319  // - Walks both arrays (current and updates), and calls user provided functions on each comparison.
320  // - Returns false on any error. Always completes walks of both arrays.
321  // - fnExists = void (T_ITEM& in_item, const tUpdate& in_update);
322  // - fnNew = void (T_ITEM& in_item, const tUpdate& in_update);
323  // - fnOld = bool (T_ITEM& in_item); // return value indicates if entry should be deleted.
324  template <typename T_UPDATE>
326  {
327  static const T_KEY& Get(const T_UPDATE& in) { return in; }
328  };
329 
330  template <
331  typename T_UPDATE,
332  typename U_UPDATEKEY = GetUpdateKey<T_UPDATE>,
333  typename FN_EXISTS = void (*)(T_ITEM&, const T_UPDATE&),
334  typename FN_NEW = void (*)(T_ITEM&, const T_UPDATE&),
335  typename FN_OLD = void (*)(T_ITEM&)
336  >
337  bool SortedUpdate(AkUInt32 in_numUpdates, const T_UPDATE* in_pUpdates, FN_EXISTS in_fnExists, FN_NEW in_fnNew, FN_OLD in_fnOld)
338  {
339  #ifndef AK_OPTIMIZED
340  // Updates must be sorted.
341  for (AkUInt32 i = 1; i < in_numUpdates; ++i)
342  {
343  const T_KEY& a = U_UPDATEKEY::Get(in_pUpdates[i-1]);
344  const T_KEY& b = U_UPDATEKEY::Get(in_pUpdates[i]);
345  if (!Lesser(a, b) && !Equal(a, b))
346  {
347  AKASSERT(!"AkSortedKeyArray::SortedUpdate, input not sorted!");
348  return false;
349  }
350  }
351 
352  // Array must be sorted.
353  for (AkUInt32 i = 1; i < this->Length(); ++i)
354  {
355  T_KEY& a = U_KEY::Get(this->m_pItems[i-1]);
356  T_KEY& b = U_KEY::Get(this->m_pItems[i]);
357  if (!Lesser(a, b) && !Equal(a, b))
358  {
359  AKASSERT(!"AkSortedKeyArray::SortedUpdate, array not sorted!");
360  return false;
361  }
362  }
363  #endif
364 
365  bool bResult = true;
366 
367  // Walk through both arrays while not having reached the end of either.
368  AkUInt32 oldIdx = 0, newIdx = 0;
369  while (oldIdx < this->Length() && newIdx < in_numUpdates)
370  {
371  T_ITEM& oldItem = this->m_pItems[oldIdx];
372  T_KEY& oldKey = U_KEY::Get(oldItem);
373 
374  const T_UPDATE& newItem = in_pUpdates[newIdx];
375  const T_KEY& newKey = U_UPDATEKEY::Get(newItem);
376 
377  if (Equal(oldKey, newKey))
378  {
379  // Common item. Call user function, then move one.
380  in_fnExists(oldItem, newItem);
381  ++oldIdx;
382  ++newIdx;
383  }
384  else if (Lesser(oldKey, newKey))
385  {
386  // Call user function; return value determines if we delete the entry.
387  if (in_fnOld(oldItem))
388  this->Erase(oldIdx);
389  else
390  ++oldIdx;
391 
392  // Don't increment oldIdx!
393  }
394  else // if (oldKey > newKey)
395  {
396  // New entry. Insert, then call user function.
397  T_ITEM* pNew = this->Insert(oldIdx);
398  if (pNew)
399  {
400  U_KEY::Get(*pNew) = newKey;
401  in_fnNew(*pNew, newItem);
402  ++oldIdx;
403  }
404  else
405  bResult = false;
406 
407  ++newIdx;
408  }
409  }
410 
411  // Remove any leftover old items.
412  while (oldIdx < this->Length())
413  {
414  if (in_fnOld(this->m_pItems[oldIdx]))
415  this->Erase(oldIdx);
416  else
417  ++oldIdx;
418  }
419 
420  // Add any leftover new items.
421  for (; newIdx < in_numUpdates; ++newIdx)
422  {
423  const T_UPDATE& newItem = in_pUpdates[newIdx];
424  const T_KEY& newKey = U_UPDATEKEY::Get(newItem);
425 
426  T_ITEM* pNew = this->AddLast();
427  if (pNew)
428  {
429  U_KEY::Get(*pNew) = newKey;
430  in_fnNew(*pNew, newItem);
431  }
432  else
433  bResult = false;
434  }
435 
436  return bResult;
437  }
438 
439  // WARNING: Do not use on types that need constructors or destructor called on Item objects at each creation.
440 
441  void Reorder(T_KEY in_OldKey, T_KEY in_NewKey, const T_ITEM & in_item)
442  {
443  bool bFound;
444  T_ITEM * pItem = BinarySearch(in_OldKey, bFound);
445 
446  //AKASSERT( bFound );
447  if (!bFound) return;// cannot be an assert for now.(WG-19496)
448 
449  unsigned int uIdx = (unsigned int)(pItem - this->m_pItems);
450  unsigned int uLastIdx = this->Length() - 1;
451 
452  AKASSERT(*pItem == in_item);
453 
454  bool bNeedReordering = false;
455  if (uIdx > 0) // if not first
456  {
457  T_ITEM * pPrevItem = this->m_pItems + (uIdx - 1);
458  if (Lesser(in_NewKey, U_KEY::Get(*pPrevItem)))
459  {
460  // Check one step further
461  if (uIdx > 1)
462  {
463  T_ITEM * pSecondPrevItem = this->m_pItems + (uIdx - 2);
464  if (Lesser(U_KEY::Get(*pSecondPrevItem), in_NewKey))
465  {
466  return Swap(pPrevItem, pItem);
467  }
468  else
469  {
470  bNeedReordering = true;
471  }
472  }
473  else
474  {
475  return Swap(pPrevItem, pItem);
476  }
477  }
478  }
479  if (!bNeedReordering && uIdx < uLastIdx)
480  {
481  T_ITEM * pNextItem = this->m_pItems + (uIdx + 1);
482  if (Lesser(U_KEY::Get(*pNextItem), in_NewKey))
483  {
484  // Check one step further
485  if (uIdx < (uLastIdx - 1))
486  {
487  T_ITEM * pSecondNextItem = this->m_pItems + (uIdx + 2);
488  if (Lesser(in_NewKey, U_KEY::Get(*pSecondNextItem)))
489  {
490  return Swap(pNextItem, pItem);
491  }
492  else
493  {
494  bNeedReordering = true;
495  }
496  }
497  else
498  {
499  return Swap(pNextItem, pItem);
500  }
501  }
502  }
503 
504  if (bNeedReordering)
505  {
506  /////////////////////////////////////////////////////////
507  // Faster implementation, moving only what is required.
508  /////////////////////////////////////////////////////////
509  unsigned int uIdxToInsert; // non initialized
510  T_ITEM * pTargetItem = BinarySearch(in_NewKey, bFound);
511  if (pTargetItem)
512  {
513  uIdxToInsert = (unsigned int)(pTargetItem - this->m_pItems);
514  if (uIdxToInsert > uIdx)
515  {
516  --uIdxToInsert;// we are still in the list, don't count the item to be moved.
517  }
518  }
519  else
520  {
521  uIdxToInsert = uLastIdx;
522  }
523 
524  T_ITEM * pStartItem = this->m_pItems + uIdx;
525  T_ITEM * pEndItem = this->m_pItems + uIdxToInsert;
526  if (uIdxToInsert < uIdx)
527  {
528  // Slide backward.
529  while (pStartItem != pEndItem)
530  {
531  --pStartItem;
532  pStartItem[1] = pStartItem[0];
533  }
534  }
535  else
536  {
537  // Slide forward.
538  while (pStartItem != pEndItem)
539  {
540  pStartItem[0] = pStartItem[1];
541  ++pStartItem;
542  }
543  }
544  pEndItem[0] = in_item;
545  ///////////////////////////////////////////////
546  }
547  }
548 
549  // WARNING: Do not use on types that need constructors or destructor called on Item objects at each creation.
550 
551  void ReSortArray() //To be used when the < > operator changed meaning.
552  {
553  AkInt32 NumItemsToReInsert = this->Length();
554  if (NumItemsToReInsert != 0)
555  {
556  // Do a re-insertion sort.
557  // Fool the table by faking it is empty, then re-insert one by one.
558  T_ITEM * pReinsertionItem = this->m_pItems;
559  this->m_uLength = 0; // Faking the Array Is Empty.
560  for (AkInt32 idx = 0; idx < NumItemsToReInsert; ++idx)
561  {
562  T_ITEM ItemtoReinsert = pReinsertionItem[idx]; // make a copy as the source is about to be overriden.
563 
564  T_KEY keyToReinsert = U_KEY::Get(ItemtoReinsert);
565 
566  T_ITEM* pInsertionEmplacement = AddNoSetKey(keyToReinsert);
567 
568  AKASSERT(pInsertionEmplacement);
569  *pInsertionEmplacement = ItemtoReinsert;
570  }
571  }
572  }
573 
574  // If found, returns the first item it encounters, if not, returns the insertion point.
575  T_ITEM * BinarySearch( T_KEY in_key, bool & out_bFound ) const
576  {
577  AkUInt32 uNumToSearch = this->Length();
578  AkInt32 iBase = 0;
579  AkInt32 iPivot = 0;
580 
581  while ( uNumToSearch > 0 )
582  {
583  iPivot = iBase + ( uNumToSearch >> 1 );
584  T_KEY pivotKey = U_KEY::Get( this->m_pItems[ iPivot ] );
585  if ( Equal( pivotKey, in_key ) )
586  {
587  out_bFound = true;
588  return this->m_pItems + iPivot;
589  }
590 
591  if ( Lesser( pivotKey, in_key ) )
592  {
593  iBase = iPivot + 1;
594  uNumToSearch--;
595  }
596  uNumToSearch >>= 1;
597  }
598 
599  out_bFound = false;
600  return this->m_pItems + iBase;
601  }
602 
603  T_ITEM* LowerBounds(T_KEY in_key) const
604  {
605  return LowerBounds(in_key, this->Begin(), this->End());
606  }
607 
608  // Returns the first item in the array that is not less than the key,
609  // or the insertion point, if no key is less then in_key.
610  T_ITEM* LowerBounds(T_KEY in_key, Iterator in_from, Iterator in_to) const
611  {
612  AKASSERT(in_to.pItem >= in_from.pItem);
613  AkUInt32 uBase = (AkUInt32)(in_from.pItem - this->m_pItems);
614  AkInt64 uNumToSearch = (AkInt64)(in_to.pItem - in_from.pItem);
615  AkUInt32 uPivot;
616 
617  while (uNumToSearch > 0)
618  {
619  uPivot = uBase + (AkUInt32)(uNumToSearch >> 1);
620  T_KEY pivotKey = U_KEY::Get(this->m_pItems[uPivot]);
621  if (Lesser(pivotKey, in_key))
622  {
623  uBase = uPivot + 1;
624  uNumToSearch--;
625  }
626  uNumToSearch >>= 1;
627  }
628 
629  return this->m_pItems + uBase;
630  }
631 
632  AkForceInline void Swap(T_ITEM * in_ItemA, T_ITEM * in_ItemB)
633  {
634  T_ITEM ItemTemp = *in_ItemA;
635  *in_ItemA = *in_ItemB;
636  *in_ItemB = ItemTemp;
637  }
638 };
639 
640 
641 #endif //_KEYARRAY_H_
T_ITEM * Exists(T_KEY in_Key) const
Definition: AkKeyArray.h:43
T_ITEM * Set(T_KEY in_Key, const T_ITEM &in_Item)
Definition: AkKeyArray.h:54
AkArray< MapStruct< T_KEY, T_ITEM >, const MapStruct< T_KEY, T_ITEM > &, U_POOL, TGrowBy, TMovePolicy >::Iterator FindEx(T_KEY in_Item) const
Definition: AkKeyArray.h:112
T_ITEM * Set(T_KEY in_key, bool &out_bExists)
Definition: AkKeyArray.h:282
T_ITEM * Set(T_KEY in_Key)
Definition: AkKeyArray.h:94
Key policy for AkSortedKeyArray.
Definition: AkKeyArray.h:155
T_ITEM * LowerBounds(T_KEY in_key, Iterator in_from, Iterator in_to) const
Definition: AkKeyArray.h:610
AkForceInline bool Equal(const T_KEY &a, const T_KEY &b) const
Definition: AkKeyArray.h:214
bool SortedUpdate(AkUInt32 in_numUpdates, const T_UPDATE *in_pUpdates, FN_EXISTS in_fnExists, FN_NEW in_fnNew, FN_OLD in_fnOld)
Definition: AkKeyArray.h:337
T_ITEM * Exists(T_KEY in_key) const
Definition: AkKeyArray.h:230
T_ITEM * LowerBounds(T_KEY in_key) const
Definition: AkKeyArray.h:603
Specific implementation of array
Definition: AkArray.h:260
#define NULL
Definition: AkTypes.h:46
int32_t AkInt32
Signed 32-bit integer
T_ITEM item
Definition: AkKeyDef.h:37
T_ITEM * BinarySearch(T_KEY in_key, bool &out_bFound) const
Definition: AkKeyArray.h:575
static AkForceInline bool Equal(THIS_CLASS *, const T_KEY &a, const T_KEY &b)
Definition: AkKeyArray.h:194
T_ITEM * AddNoSetKey(T_KEY in_key, bool &out_bFound)
Definition: AkKeyArray.h:258
AkForceInline void Swap(T_ITEM *in_ItemA, T_ITEM *in_ItemB)
Definition: AkKeyArray.h:632
#define AKASSERT(Condition)
Definition: AkAssert.h:67
static const T_KEY & Get(const T_UPDATE &in)
Definition: AkKeyArray.h:327
AkForceInline bool Lesser(const T_KEY &a, const T_KEY &b) const
Definition: AkKeyArray.h:209
T_ITEM * SetFirst(T_KEY in_Key, const T_ITEM &in_Item)
Definition: AkKeyArray.h:74
Trivial key policy for AkSortedKeyArray, when T_KEY is T_ITEM.
Definition: AkKeyArray.h:174
T_ITEM * Add(T_KEY in_key)
Definition: AkKeyArray.h:239
static AkForceInline bool Lesser(THIS_CLASS *, const T_KEY &a, const T_KEY &b)
Definition: AkKeyArray.h:188
AkUInt32 GetIndex(T_ITEM *in_pItem) const
Definition: AkKeyArray.h:219
int64_t AkInt64
Signed 64-bit integer
AkForceInline AkUInt32 Length() const
Returns the numbers of items in the array.
Definition: AkArray.h:568
static AkForceInline T_KEY & Get(T_ITEM &in_item)
Default policy.
Definition: AkKeyArray.h:166
static AkForceInline T_KEY & Get(T_ITEM &in_item)
Default policy.
Definition: AkKeyArray.h:157
uint32_t AkUInt32
Unsigned 32-bit integer
T_ITEM * AddNoSetKey(T_KEY in_key)
Definition: AkKeyArray.h:252
void UnsetSwap(T_KEY in_Key)
Definition: AkKeyArray.h:143
void ReSortArray()
Definition: AkKeyArray.h:551
bool Unset(T_KEY in_key)
Definition: AkKeyArray.h:304
void Unset(T_KEY in_Key)
Definition: AkKeyArray.h:130
static AkForceInline T_KEY & Get(T_KEY &in_item)
Default policy.
Definition: AkKeyArray.h:177
#define AkForceInline
Definition: AkTypes.h:63
void Reorder(T_KEY in_OldKey, T_KEY in_NewKey, const T_ITEM &in_item)
Definition: AkKeyArray.h:441
T_KEY key
Definition: AkKeyDef.h:36
T_ITEM * Set(T_KEY in_key)
Definition: AkKeyArray.h:276

このページはお役に立ちましたか?

サポートは必要ですか?

ご質問や問題、ご不明点はございますか?お気軽にお問い合わせください。

サポートページをご確認ください

あなたのプロジェクトについて教えてください。ご不明な点はありませんか。

プロジェクトを登録していただくことで、ご利用開始のサポートをいたします。

Wwiseからはじめよう