Audiokinetic

Wwise SDK 2024.1.0

 /*******************************************************************************
 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
 released in source code form as part of the SDK installer package.
  
 Commercial License Usage
  
 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
 may use this file in accordance with the end user license agreement provided 
 with the software or, alternatively, in accordance with the terms contained in a
 written agreement between you and Audiokinetic Inc.
  
 Apache License Usage
  
 Alternatively, this file may be used under the Apache License, Version 2.0 (the 
 "Apache License"); you may not use this file except in compliance with the 
 Apache License. You may obtain a copy of the Apache License at 
 http://www.apache.org/licenses/LICENSE-2.0.
  
 Unless required by applicable law or agreed to in writing, software distributed
 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
 the specific language governing permissions and limitations under the License.
  
   Copyright (c) 2024 Audiokinetic Inc.
 *******************************************************************************/
  
 /**
  * \brief Wwise Authoring Plug-ins - API to provide custom undo event and manage undo groups.
  * \file AK/Wwise/Plugin/HostUndoManager.h
  */
  
 #pragma once
  
 #include "HostPropertySet.h"
  
 /**
  * \brief API to create a custom undo event in a plug-in.
  * 
  * This is useful when you handle custom properties, not handled by Property Sets.
  */
 struct ak_wwise_plugin_undo_event_v1
 #ifdef __cplusplus
     : public ak_wwise_plugin_base_interface
 #endif
 {
 #ifndef __cplusplus
     ak_wwise_plugin_base_interface m_baseInterface;
 #endif
  
 #ifdef __cplusplus
     /// Base instance type for providing custom undo operations.
     using Instance = ak_wwise_plugin_undo_event_instance_v1;
  
     ak_wwise_plugin_undo_event_v1() :
         ak_wwise_plugin_base_interface(AK_WWISE_PLUGIN_INTERFACE_TYPE_UNDO_EVENT, 1)
     {}
     ak_wwise_plugin_undo_event_v1(decltype(m_interface) in_interface, decltype(m_version) in_version) :
         ak_wwise_plugin_base_interface(in_interface, in_version)
     {}
     ak_wwise_plugin_undo_event_v1(std::underlying_type<decltype(m_interface)>::type in_interface, decltype(m_version) in_version) :
         ak_wwise_plugin_base_interface((decltype(m_interface))in_interface, in_version)
     {}
 #endif
  
     /**
      * \brief Called when the system needs to destroy your ak_wwise_plugin_undo_event_v1 instance.
      * 
      * Since your plug-in created the instance, you are responsible for destroying it.
      * 
      * \param[in] in_this Current instance of this Undo Event instance.
      */
     void(*Destroy)(struct ak_wwise_plugin_undo_event_instance_v1* in_this);
  
     /**
      * \brief Called when the user asks to undo an action.
      * 
      * \akwarning The backend instance is provided to you. You should never keep pointers to any plug-in instances
      *            or services, as these might have been deleted and recreated in the meantime. \endakwarning
      * 
      * \param[in] in_this Current instance of this Undo Event.
      * \param[in] in_backend The backend instance that created this event.
      */
     bool(*Undo)(
         struct ak_wwise_plugin_undo_event_instance_v1* in_this,
         struct ak_wwise_plugin_backend_instance* in_backend);
  
     /**
      * \brief Called when the user asks to redo an action.
      * 
      * \akwarning The backend instance is provided to you. You should never keep pointers to any plug-in instances
      *            or services, as these might have been deleted and recreated in the meantime. \endakwarning
      * 
      * \param[in] in_this Current instance of this Undo Event instance.
      * \param[in] in_backend The backend instance that created this event.
      */
     bool(*Redo)(
         struct ak_wwise_plugin_undo_event_instance_v1* in_this,
         struct ak_wwise_plugin_backend_instance* in_backend);
  
     /**
      * \brief Get the event name, to show after the "Undo " and "Redo " terms in the menu.
      * 
      * \param[in] in_this Current instance of this Undo Event.
      * \param[out] out_csName Pointer to a static name for this event. The buffer is owned by Authoring and is 
      *   valid until the next API call.
      * \return true if successful.
      */
     bool(*GetName)(
         const struct ak_wwise_plugin_undo_event_instance_v1* in_this,
         const char ** out_csName);
 };
 #define AK_WWISE_PLUGIN_UNDO_EVENT_V1_ID() \
     AK_WWISE_PLUGIN_BASE_INTERFACE_FROM_ID(AK_WWISE_PLUGIN_INTERFACE_TYPE_UNDO_EVENT, 1)
 #define AK_WWISE_PLUGIN_UNDO_EVENT_V1_CTOR() \
 { \
     .m_baseInterface = AK_WWISE_PLUGIN_BASE_INTERFACE_FROM_ID(AK_WWISE_PLUGIN_UNDO_EVENT_V1_ID()) \
 }
  
  
 /**
  * \brief Host API to handle the plug-in's undo operations.
  */
 struct ak_wwise_plugin_host_undo_manager_v1
 #ifdef __cplusplus
     : public ak_wwise_plugin_base_interface
 #endif
 {
 #ifndef __cplusplus
     ak_wwise_plugin_base_interface m_baseInterface;
 #endif
  
 #ifdef __cplusplus
     /// Base host-provided instance type for ak_wwise_plugin_host_undo_manager_v1.
     using Instance = ak_wwise_plugin_host_undo_manager_instance_v1;
  
     ak_wwise_plugin_host_undo_manager_v1() :
         ak_wwise_plugin_base_interface(AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_UNDO_MANAGER, 1)
     {}
 #endif
  
     /**
      * \brief Open a group that will contain all subsequent undo events.
      * 
      * This must be done prior to performing any action on PropertySets, or adding custom events, as it is important to
      * have one unique element on the undo stack. You can open multiple groups at once, like a stack, as long as you
      * close them before exiting your function.
      * 
      * in_reopenGroupId should be set to 0 for a new group.
      * 
      * Example:
      * <code>
      * ak_wwise_plugin_undo_group_id m_dragAndDropGroupId = 0;
      * m_dragAndDropGroupId = OpenGroup(this, m_dragAndDropGroupId);
      * if (m_dragAndDropGroupId == 0) return;
      * CloseGroup(this,
      *            m_done ? AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY :
      *                     AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_CLOSE,
      *            "Drag and drop");
      * if (m_done) m_dragAndDropGroupId = 0;
      * </code>
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_reopenGroupId Previously opened undo group, or 0 for a new group.
      * \return The new undo group that just got created, or 0 if the system cannot open a group at the moment.
      */
     ak_wwise_plugin_undo_group_id (*OpenGroup)(
         struct ak_wwise_plugin_host_undo_manager_instance_v1* in_this,
         ak_wwise_plugin_undo_group_id in_reopenGroupId);
  
     /**
      * \brief Closes the last opened group, in stack ordering.
      * 
      * Close the current group (_CLOSE) and add its content as a unique entry to the previous group,
      * or to the Undo stack (_APPLY), or cancel its contents (_CANCEL).
      * 
      * in_szApplyEventName is only used for _APPLY. It is ignored elsewhere, and needs to be nullptr on
      * _APPLY_FIRST_EVENT_NAME or _APPLY_LAST_EVENT_NAME.
      * 
      * in_groupId is only for validation, you can pass 0 if you do not wish to provide this validation.
      * 
      * \akwarning Cancelling contents doesn't undo all the grouped actions. You are responsible for doing all the proper
      *            undoing before closing the group. \akwarning
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_action Action to perform when closing the group. Should usually
      *            be AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY. 
      * \param[in] in_groupId (Optional, pass 0) Validation to make sure the group being closed has the proper ID.
      * \param[in] in_szApplyEventName Event name. Added after "Undo " and "Redo " in the menu.
      * \return true if successful.
      */
     bool(*CloseGroup)(
         struct ak_wwise_plugin_host_undo_manager_instance_v1* in_this,
         ak_wwise_plugin_undo_group_close_action in_action,
         ak_wwise_plugin_undo_group_id in_groupId,
         const char * in_szApplyEventName);
  
     /**
      * \brief Adds a custom event to the currently opened group.
      * 
      * By default, you should be in a group while adding an event.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_event Event to add to the current group.
      * \return true if successful.
      */
     bool(*AddCustomEvent)(
         struct ak_wwise_plugin_host_undo_manager_instance_v1* in_this,
         struct ak_wwise_plugin_undo_event_pair_v1 in_event);
  
     /**
      * \brief Check if we are currently in a state where we can add undo events.
      * 
      * This is different than not being in a group. You should always be in a group when you want to add an event.
      * 
      * \param[in] in_this Current instance of this interface.
      * \return true if we can add an event.
      */
     bool(*CanAddEvent)(const struct ak_wwise_plugin_host_undo_manager_instance_v1* in_this);
  
     /**
      * \brief Check if we are busy (undoing or redoing).
      * 
      * \param[in] in_this Current instance of this interface.
      * \return true if we are currently performing an undo operation.
      */
     bool(*IsBusy)(const struct ak_wwise_plugin_host_undo_manager_instance_v1* in_this);
  
     /**
      * \brief Returns whether logging can occur or not.
      * 
      * Call this function when you are about to log an undo event to know if Wwise is in a state
      * where undos are enabled. Undo logging can be disabled for a particular plug-in object if
      * it already lives in the undo stack or in the clipboard.
      * 
      * This function is useful to determine whether a complex undo operation can be started without opening a
      * new undo group (see \ref ak_wwise_plugin_host_undo_manager_v1::OpenGroup). Otherwise, the simple fact of
      * opening an undo group will give a result of 0 if it's not possible to log undos at this time.
      * 
      * \param[in] in_this Current instance of this interface.
      * \return true if the plug-in can log undo events at this time.
      */
     bool(*CanLogUndos)(
         const struct ak_wwise_plugin_host_undo_manager_instance_v1* in_this);
 };
 #define AK_WWISE_PLUGIN_HOST_UNDO_MANAGER_V1_ID() \
     AK_WWISE_PLUGIN_BASE_INTERFACE_FROM_ID(AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_UNDO_MANAGER, 1)
 #define AK_WWISE_PLUGIN_HOST_UNDO_MANAGER_V1_CTOR() \
 { \
     .m_baseInterface = AK_WWISE_PLUGIN_HOST_UNDO_MANAGER_V1_ID() \
 }
  
  
 #ifdef __cplusplus
 namespace AK::Wwise::Plugin
 {
     namespace V1
     {
         using CUndoEvent = ak_wwise_plugin_undo_event_v1;
         using CUndoEventPair = ak_wwise_plugin_undo_event_pair_v1;
  
         /**
          * \brief Base API to create a custom undo event in a plug-in.
          * 
          * This is useful when you handle custom properties, not handled by Property Sets.
          * 
          * UndoEvent should be handled by the \ref UndoEvent template.
          */
         class BaseUndoEvent : public CUndoEvent::Instance
         {
         public:
             /**
              * \brief The interface type, as provided by this plug-in.
              */
             enum : InterfaceTypeValue
             {
                 /**
                  * \brief The interface type, as provided by this plug-in.
                  */
                 k_interfaceType = AK_WWISE_PLUGIN_INTERFACE_TYPE_UNDO_EVENT
             };
             /**
              * \brief The interface version, as provided by this plug-in.
              */
             enum : InterfaceVersion
             {
                 /**
                  * \brief The interface version, as provided by this plug-in.
                  */
                 k_interfaceVersion = 1
             };
  
             using Interface = CUndoEvent;
  
             virtual Interface* GetInterfacePointer() = 0;
  
             CUndoEvent::Instance* GetInstancePointer() {
                 return this;
             }
  
             const CUndoEvent::Instance* GetInstancePointer() const {
                 return this;
             }
  
             BaseUndoEvent() :
                 CUndoEvent::Instance()
             {
             }
  
             virtual ~BaseUndoEvent() {}
         };
  
         /**
          * \brief Base API to create a custom undo event in a plug-in.
          * 
          * This is useful when you handle custom properties, not handled by Property Sets.
          * 
          * Undo events should be derived by your undo class, providing \ref UndoEvent::Undo,
          * \ref UndoEvent::Redo and \ref UndoEvent::GetName methods.
          * 
          * No pointer to the backend class should be kept inside the undo event, as the object can be deleted
          * and recreated when the plug-in gets removed through undo. The backend will be recreated at that point,
          * making the pointer invalid.
          * 
          * \tparam Backend The plug-in backend type.
          */
         template<typename Backend>
         class UndoEvent : public BaseUndoEvent
         {
         public:
             struct Interface : public BaseUndoEvent::Interface
             {
                 using Instance = UndoEvent;
  
                 /**
                  * \brief The C interface, fulfilled by your plug-in.
                  */
                 Interface()
                 {
                     CUndoEvent::Destroy = [](
                         struct ak_wwise_plugin_undo_event_instance_v1* in_this)
                     {
                         delete static_cast<Instance*>(in_this);
                     };
                     CUndoEvent::Undo = [](
                         struct ak_wwise_plugin_undo_event_instance_v1* in_this,
                         struct ak_wwise_plugin_backend_instance* in_backend)
                     {
                         return (bool)static_cast<Instance*>(in_this)->Undo(*static_cast<Backend*>(in_backend));
                     };
                     CUndoEvent::Redo = [](
                         struct ak_wwise_plugin_undo_event_instance_v1* in_this,
                         struct ak_wwise_plugin_backend_instance* in_backend)
                     {
                         return (bool)static_cast<Instance*>(in_this)->Redo(*static_cast<Backend*>(in_backend));
                     };
                     CUndoEvent::GetName = [](
                         const struct ak_wwise_plugin_undo_event_instance_v1* in_this,
                         const char ** out_csName)
                     {
                         return (bool)static_cast<const Instance*>(in_this)->GetName(
                             out_csName);
                     };
                 }
             };
  
             virtual BaseUndoEvent::Interface* GetInterfacePointer() final {
                 static Interface g_interface;
                 return &g_interface;
             }
  
             /**
              * \brief Called when the user asks to undo an action.
              * 
              * \akwarning The backend instance is provided to you. You should never keep pointers to any plug-in instances
              *            or services, as these might have been deleted and recreated in the meantime. \endakwarning
              * 
              * \param[in] in_backend The backend instance that created this event.
              */
             virtual bool Undo(Backend& in_backend) = 0;
  
             /**
              * \brief Called when the user asks to redo an action.
              * 
              * \akwarning The backend instance is provided to you. You should never keep pointers to any plug-in instances
              *            or services, as these might have been deleted and recreated in the meantime. \endakwarning
              * 
              * \param[in] in_backend The backend instance that created this event.
              */
             virtual bool Redo(Backend& in_backend) = 0;
  
             /**
              * \brief Get the event name, to show after the "Undo " and "Redo " terms in the menu.
              * 
              * \param[out] out_csName Pointer to a static name for this event. This pointer needs to be accessible as long
              *             as the event is not destroyed.
              * \return true if successful.
              */
             virtual bool GetName(const char ** out_csName) const = 0;
         };
  
         template<typename BackendDerivedClass>
         class DynamicUndoEvent : public BaseUndoEvent
         {
         public:
             struct Interface : public BaseUndoEvent::Interface
             {
                 using Instance = DynamicUndoEvent;
  
                 /**
                  * \brief The C interface, fulfilled by your plug-in.
                  */
                 Interface()
                 {
                     CUndoEvent::Destroy = [](
                         struct ak_wwise_plugin_undo_event_instance_v1* in_this)
                     {
                         delete static_cast<Instance*>(in_this);
                     };
                     CUndoEvent::Undo = [](
                         struct ak_wwise_plugin_undo_event_instance_v1* in_this,
                         struct ak_wwise_plugin_backend_instance* in_backend)
                     {
                         BackendDerivedClass *backend = dynamic_cast<BackendDerivedClass*>(in_backend);
                         if (backend)
                             return (bool)static_cast<Instance*>(in_this)->Undo(*backend);
                         else
                             return false;
                     };
                     CUndoEvent::Redo = [](
                         struct ak_wwise_plugin_undo_event_instance_v1* in_this,
                         struct ak_wwise_plugin_backend_instance* in_backend)
                     {
                         BackendDerivedClass *backend = dynamic_cast<BackendDerivedClass*>(in_backend);
                         if (backend)
                             return (bool)static_cast<Instance*>(in_this)->Redo(*backend);
                         else
                             return false;
                     };
                     CUndoEvent::GetName = [](
                         const struct ak_wwise_plugin_undo_event_instance_v1* in_this,
                         const char ** out_csName)
                     {
                         return (bool)static_cast<const Instance*>(in_this)->GetName(
                             out_csName);
                     };
                 }
             };
  
             virtual BaseUndoEvent::Interface* GetInterfacePointer() final {
                 static Interface g_interface;
                 return &g_interface;
             }
  
             /**
              * \brief Called when the user asks to undo an action.
              * 
              * \akwarning The backend instance is provided to you. You should never keep pointers to any plug-in instances
              *            or services, as these might have been deleted and recreated in the meantime. \endakwarning
              * 
              * \param[in] in_backend The backend instance that created this event.
              */
             virtual bool Undo(BackendDerivedClass& in_backend) = 0;
  
             /**
              * \brief Called when the user asks to redo an action.
              * 
              * \akwarning The backend instance is provided to you. You should never keep pointers to any plug-in instances
              *            or services, as these might have been deleted and recreated in the meantime. \endakwarning
              * 
              * \param[in] in_backend The backend instance that created this event.
              */
             virtual bool Redo(BackendDerivedClass& in_backend) = 0;
  
             /**
              * \brief Get the event name, to show after the "Undo " and "Redo " terms in the menu.
              * 
              * \param[out] out_csName Pointer to a static name for this event. The buffer is owned by Authoring and is 
              *   valid until the next API call.
              * \return true if successful.
              */
             virtual bool GetName(const char ** out_csName) const = 0;
         };
  
         using CHostUndoManager = ak_wwise_plugin_host_undo_manager_v1;
  
         /// \copydoc ak_wwise_plugin_host_undo_manager_v1
         class UndoManager : public CBaseInstanceGlue<CHostUndoManager>
         {
         public:
             using Interface = CHostUndoManager;
  
             /**
              * \brief The interface type, as requested by this plug-in.
              */
             enum : InterfaceTypeValue
             {
                 /**
                  * \brief The interface type, as requested by this plug-in.
                  */
                 k_interfaceType = AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_UNDO_MANAGER
             };
             /**
              * \brief The interface version, as requested by this plug-in.
              */
             enum : InterfaceVersion
             {
                 /**
                  * \brief The interface version, as requested by this plug-in.
                  */
                 k_interfaceVersion = 1
             };
  
             /**
              * \brief Open a group that will contain all subsequent undo events.
              * 
              * This must be done prior to performing any action on PropertySets, or adding custom events, as it is important to
              * have one unique element on the undo stack. You can open multiple groups at once, like a stack, as long as you
              * close them before exiting your function.
              * 
              * in_reopenGroupId should be set to 0 for a new group.
              * 
              * Example:
              * <code>
              * ak_wwise_plugin_undo_group_id m_dragAndDropGroupId = 0;
              * m_dragAndDropGroupId = OpenGroup(this, m_dragAndDropGroupId);
              * if (m_dragAndDropGroupId == 0) return;
              * CloseGroup(this,
              *            m_done ? AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY :
              *                     AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_CLOSE,
              *            "Drag and drop");
              * if (m_done) m_dragAndDropGroupId = 0;
              * </code>
              * 
              * \param[in] in_reopenGroupId Previously opened undo group, or 0 for a new group.
              * \return The new undo group that just got created, or 0 if the system cannot open a group at the moment.
              */
             inline ak_wwise_plugin_undo_group_id OpenGroup(ak_wwise_plugin_undo_group_id in_reopenGroupId = 0)
             {
                 return g_cinterface->OpenGroup(this, in_reopenGroupId);
             }
  
             /**
              * \brief Closes the last opened group, in stack ordering.
              * 
              * Close the current group (_CLOSE) and add its content as a unique entry to the previous group,
              * or to the Undo stack (_APPLY), or cancel its contents (_CANCEL).
              * 
              * in_szApplyEventName is only used for _APPLY. It is ignored elsewhere, and needs to be nullptr on
              * _APPLY_FIRST_EVENT_NAME or _APPLY_LAST_EVENT_NAME.
              * 
              * in_groupId is only for validation, you can pass 0 if you do not wish to provide this validation.
              * 
              * \akwarning Cancelling contents doesn't undo all the grouped actions. You are responsible for doing all the proper
              *            undoing before closing the group. \akwarning
              * 
              * \param[in] in_action Action to perform when closing the group. Should usually
              *            be AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY. 
              * \param[in] in_groupId (Optional, pass 0) Validation to make sure the group being closed has the proper ID.
              * \param[in] in_szApplyEventName Event name. Added after "Undo " and "Redo " in the menu.
              * \return true if successful and necessary (contains real changes).
              */
             inline bool CloseGroup(
                 ak_wwise_plugin_undo_group_close_action in_action = AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY,
                 ak_wwise_plugin_undo_group_id in_groupId = 0,
                 const char * in_szApplyEventName = nullptr)
             {
                 return MKBOOL(g_cinterface->CloseGroup(this, in_action, in_groupId, in_szApplyEventName));
             }
  
             /**
              * \brief Adds a custom event to the currently opened group.
              * 
              * By default, you should be in a group while adding an event.
              * 
              * \param[in] in_pEvent Event to add to the current group.
              * \return true if successful.
              */
             inline bool AddCustomEvent(BaseUndoEvent* in_pEvent)
             {
                 return MKBOOL(g_cinterface->AddCustomEvent(
                     this,
                     {in_pEvent->GetInterfacePointer(), in_pEvent->GetInstancePointer() }));
             }
  
             /**
              * \brief Check if we are currently in a state where we can add undo events.
              * 
              * This is different than not being in a group. You should always be in a group when you want to add an event.
              * 
              * \return true if we can add an event.
              */
             inline bool CanAddEvent() const
             {
                 return MKBOOL(g_cinterface->CanAddEvent(this));
             }
  
             /**
              * \brief Check if we are busy (undoing or redoing).
              * 
              * \return true if we are currently performing an undo operation.
              */
             inline bool IsBusy() const
             {
                 return MKBOOL(g_cinterface->IsBusy(this));
             }
  
             /**
              * \brief Returns whether logging can occur or not.
              * 
              * Call this function when you are about to log an undo event to know if Wwise is in a state
              * where undos are enabled. Undo logging can be disabled for a particular plug-in object if
              * it already lives in the undo stack or in the clipboard.
              * 
              * This function is useful to determine whether a complex undo operation can be started without opening a
              * new undo group (see \ref ak_wwise_plugin_host_undo_manager_v1::OpenGroup). Otherwise, the simple fact of
              * opening an undo group will give a result of 0 if it's not possible to log undos at this time.
              * 
              * \return true if the plug-in can log undo events at this time.
              */
             inline bool CanLogUndos() const { return g_cinterface->CanLogUndos(this) ? true : false; }
         };
  
         /**
          * \brief Requests an UndoManager interface, provided as m_undoManager variable.
          * 
          * Deriving your plug-in class from RequestUndoManager will automatically request the UndoManager
          * interface. From this point, you will be able to access the host-provided functions in the
          * \c m_undoManager variable.
          */
         using RequestUndoManager = RequestedHostInterface<UndoManager>;
  
     } // of namespace V1
  
     /// Latest version of the C UndoEvent interface.
     using CUndoEvent = V1::CUndoEvent;
     /// Latest version of the C++ BaseUndoEvent interface.
     using BaseUndoEvent = V1::BaseUndoEvent;
  
     /// Latest version of the C++ UndoEvent template helper.
     template<typename Backend>
     using UndoEvent = V1::UndoEvent<Backend>;
     /// Latest version of the C++ DynamicUndoEvent template helper.
     template<typename BackendDerivedClass>
     using DynamicUndoEvent = V1::DynamicUndoEvent<BackendDerivedClass>;
  
     /// Latest version of the C UndoManager interface.
     using CHostUndoManager = V1::CHostUndoManager;
     /// Latest version of the C++ UndoManager interface.
     using UndoManager = V1::UndoManager;
     /// Latest version of the requested C++ UndoManager interface.
     using RequestUndoManager = V1::RequestUndoManager;
  
     AK_WWISE_PLUGIN_SPECIALIZE_HOST_INTERFACE(UndoManager, undoManager);
     AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_CLASS(BaseUndoEvent);
     AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_CLASS(UndoManager);
     AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_VERSION(BaseUndoEvent);
     AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_VERSION(UndoManager);
  
     class AutoUndoGroup final
     {
     public:
         AutoUndoGroup(
             UndoManager& in_undoManager,
             const char* in_applyEventName = nullptr,
             ak_wwise_plugin_undo_group_id* in_reopenGroupId = nullptr,
             ak_wwise_plugin_undo_group_close_action in_closeAction = AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY)
             : m_undoManager(in_undoManager)
             , m_applyEventName(nullptr)
             , m_groupId(0)
             , m_reopenGroupId(in_reopenGroupId ? in_reopenGroupId : &m_groupId)
             , m_closeAction(in_closeAction)
         {
             if (in_applyEventName)
             {
                 m_applyEventName = new char[strlen(in_applyEventName)+1];
                 strcpy(m_applyEventName, in_applyEventName);
             }
             if (m_undoManager.CanAddEvent())
             {
                 *m_reopenGroupId = m_undoManager.OpenGroup(*m_reopenGroupId);
                 m_valid = m_reopenGroupId != 0;
                 AKASSERT(m_valid);
             }
             else
             {
                 m_valid = false;
             }
         }
  
         ~AutoUndoGroup()
         {
             if (m_valid)
             {
                 m_undoManager.CloseGroup(m_closeAction, *m_reopenGroupId, m_applyEventName);
                 switch (m_closeAction)
                 {
                 case AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY:
                 case AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY_FIRST_EVENT_NAME:
                 case AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY_LAST_EVENT_NAME:
                 case AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_CANCEL:
                     *m_reopenGroupId = 0;
                     break;
                 case AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_CLOSE:
                 default:
                     ;
                 }
             }
             delete[] m_applyEventName;
         }
  
         // Cancel the group once the class is destroyed.
         void Cancel()
         {
             m_closeAction = AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_CANCEL;
         }
  
         // Do not apply the group to the parent once it is closed.
         void DontApply()
         {
             m_closeAction = AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_CLOSE;
         }
         
         bool IsValid()
         {
             return m_valid;
         }
  
         UndoManager& m_undoManager;
  
         char* m_applyEventName;
  
         ak_wwise_plugin_undo_group_id m_groupId;
         ak_wwise_plugin_undo_group_id* m_reopenGroupId;
  
         ak_wwise_plugin_undo_group_close_action m_closeAction;
         bool m_valid;
     };
 } // of namespace AK::Wwise::Plugin
  
 #endif

ak_wwise_plugin_undo_event_v1::ak_wwise_plugin_undo_event_v1

ak_wwise_plugin_undo_event_v1()

Definition: HostUndoManager.h:54

AK.Wwise::Plugin::BaseUndoEvent

V1::BaseUndoEvent BaseUndoEvent

Latest version of the C++ BaseUndoEvent interface.

Definition: HostUndoManager.h:637

ak_wwise_plugin_undo_event_instance_v1

Base instance type for providing custom undo operations through ak_wwise_plugin_undo_event_v1.

Definition: PluginDef.h:905

AK.Wwise::Plugin::AutoUndoGroup::m_applyEventName

char * m_applyEventName

Definition: HostUndoManager.h:730

AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_CLOSE

@ AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_CLOSE

Close this group session (going out of scope), but do not apply it yet.

Definition: PluginDef.h:995

ak_wwise_plugin_undo_event_v1::GetName

bool(* GetName)(const struct ak_wwise_plugin_undo_event_instance_v1 *in_this, const char **out_csName)

Get the event name, to show after the "Undo " and "Redo " terms in the menu.

Definition: HostUndoManager.h:108

AK.Wwise::Plugin::V1::UndoEvent::Interface::Interface

Interface()

The C interface, fulfilled by your plug-in.

Definition: HostUndoManager.h:337

ak_wwise_plugin_host_undo_manager_instance_v1

Base host-provided instance type for ak_wwise_plugin_host_undo_manager_v1.

Definition: PluginDef.h:691

ak_wwise_plugin_host_undo_manager_v1::AddCustomEvent

bool(* AddCustomEvent)(struct ak_wwise_plugin_host_undo_manager_instance_v1 *in_this, struct ak_wwise_plugin_undo_event_pair_v1 in_event)

Adds a custom event to the currently opened group.

Definition: HostUndoManager.h:206

ak_wwise_plugin_undo_event_v1::ak_wwise_plugin_undo_event_v1

ak_wwise_plugin_undo_event_v1(decltype(m_interface) in_interface, decltype(m_version) in_version)

Definition: HostUndoManager.h:57

ak_wwise_plugin_base_interface::m_interface

ak_wwise_plugin_interface_type m_interface

Interface type (see ak_wwise_plugin_interface_type)

Definition: PluginBaseInterface.h:121

ak_wwise_plugin_undo_event_v1::ak_wwise_plugin_undo_event_v1

ak_wwise_plugin_undo_event_v1(std::underlying_type< decltype(m_interface)>::type in_interface, decltype(m_version) in_version)

Definition: HostUndoManager.h:60

AK.Wwise::Plugin::V1::UndoManager

Host API to handle the plug-in's undo operations.

Definition: HostUndoManager.h:488

AK.Wwise::Plugin::AutoUndoGroup::m_undoManager

UndoManager & m_undoManager

Definition: HostUndoManager.h:728

AK.Wwise::Plugin::V1::BaseUndoEvent

Base API to create a custom undo event in a plug-in.

Definition: HostUndoManager.h:269

AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY

@ AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY

Close this group session permanently, and apply its operations to the englobing group.

Definition: PluginDef.h:996

AK.Wwise::Plugin::AutoUndoGroup::m_valid

bool m_valid

Definition: HostUndoManager.h:736

AK.Wwise::Plugin::V1::UndoManager::CloseGroup

bool CloseGroup(ak_wwise_plugin_undo_group_close_action in_action=AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY, ak_wwise_plugin_undo_group_id in_groupId=0, const char *in_szApplyEventName=nullptr)

Closes the last opened group, in stack ordering.

Definition: HostUndoManager.h:562

AK.Wwise::Plugin::V1::BaseUndoEvent::GetInstancePointer

const CUndoEvent::Instance * GetInstancePointer() const

Definition: HostUndoManager.h:300

ak_wwise_plugin_undo_event_v1::Undo

bool(* Undo)(struct ak_wwise_plugin_undo_event_instance_v1 *in_this, struct ak_wwise_plugin_backend_instance *in_backend)

Called when the user asks to undo an action.

Definition: HostUndoManager.h:83

AK.Wwise::Plugin::CBaseInterfaceGlue< CHostUndoManager >::g_cinterface

static GluedInterface * g_cinterface

The unique instance of the CInterface interface. Defined at nullptr first, overridden by the Host onc...

Definition: PluginInfoGenerator.h:89

AK.Wwise::Plugin::InterfaceVersion

decltype(BaseInterface::m_version) InterfaceVersion

PluginInfoGenerator: Type for the m_version value in BaseInterface.

Definition: PluginInfoGenerator.h:50

ak_wwise_plugin_host_undo_manager_v1::OpenGroup

ak_wwise_plugin_undo_group_id(* OpenGroup)(struct ak_wwise_plugin_host_undo_manager_instance_v1 *in_this, ak_wwise_plugin_undo_group_id in_reopenGroupId)

Open a group that will contain all subsequent undo events.

Definition: HostUndoManager.h:166

AK_WWISE_PLUGIN_INTERFACE_TYPE_UNDO_EVENT

@ AK_WWISE_PLUGIN_INTERFACE_TYPE_UNDO_EVENT

2021.1 Undo Event. ak_wwise_plugin_undo_event_v1

Definition: PluginBaseInterface.h:71

ak_wwise_plugin_undo_event_v1

API to create a custom undo event in a plug-in.

Definition: HostUndoManager.h:45

ak_wwise_plugin_undo_event_v1::Redo

bool(* Redo)(struct ak_wwise_plugin_undo_event_instance_v1 *in_this, struct ak_wwise_plugin_backend_instance *in_backend)

Called when the user asks to redo an action.

Definition: HostUndoManager.h:96

ak_wwise_plugin_host_undo_manager_v1::CanLogUndos

bool(* CanLogUndos)(const struct ak_wwise_plugin_host_undo_manager_instance_v1 *in_this)

Returns whether logging can occur or not.

Definition: HostUndoManager.h:242

HostPropertySet.h

Wwise Authoring Plug-ins - Plug-in API for property sets.

AK.Wwise::Plugin::V1::UndoEvent::Interface

Definition: HostUndoManager.h:331

AK.Wwise::Plugin::AutoUndoGroup::~AutoUndoGroup

~AutoUndoGroup()

Definition: HostUndoManager.h:690

ak_wwise_plugin_base_interface::m_version

uint32_t m_version

Version of the interface.

Definition: PluginBaseInterface.h:122

AK.Wwise::Plugin::V1::UndoManager::k_interfaceType

@ k_interfaceType

The interface type, as requested by this plug-in.

Definition: HostUndoManager.h:500

AK.Wwise::Plugin::V1::UndoEvent::GetName

virtual bool GetName(const char **out_csName) const =0

Get the event name, to show after the "Undo " and "Redo " terms in the menu.

ak_wwise_plugin_host_undo_manager_v1::CanAddEvent

bool(* CanAddEvent)(const struct ak_wwise_plugin_host_undo_manager_instance_v1 *in_this)

Check if we are currently in a state where we can add undo events.

Definition: HostUndoManager.h:218

AK.Wwise::Plugin::V1::CUndoEvent

ak_wwise_plugin_undo_event_v1 CUndoEvent

Definition: HostUndoManager.h:258

AK.Wwise::Plugin::V1::CHostUndoManager

ak_wwise_plugin_host_undo_manager_v1 CHostUndoManager

Definition: HostUndoManager.h:484

AK.Wwise::Plugin::AutoUndoGroup::AutoUndoGroup

AutoUndoGroup(UndoManager &in_undoManager, const char *in_applyEventName=nullptr, ak_wwise_plugin_undo_group_id *in_reopenGroupId=nullptr, ak_wwise_plugin_undo_group_close_action in_closeAction=AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY)

Definition: HostUndoManager.h:662

AK.Wwise::Plugin::V1::UndoManager::AddCustomEvent

bool AddCustomEvent(BaseUndoEvent *in_pEvent)

Adds a custom event to the currently opened group.

Definition: HostUndoManager.h:578

AK.Wwise::Plugin::AutoUndoGroup

Definition: HostUndoManager.h:660

AK.Wwise::Plugin::V1::BaseUndoEvent::GetInstancePointer

CUndoEvent::Instance * GetInstancePointer()

Definition: HostUndoManager.h:296

AK.Wwise::Plugin::V1::DynamicUndoEvent::GetName

virtual bool GetName(const char **out_csName) const =0

Get the event name, to show after the "Undo " and "Redo " terms in the menu.

AK.Wwise::Plugin::V1::UndoManager::CanLogUndos

bool CanLogUndos() const

Returns whether logging can occur or not.

Definition: HostUndoManager.h:620

AK.Wwise::Plugin::V1::DynamicUndoEvent::Interface

Definition: HostUndoManager.h:406

AK.Wwise::Plugin::V1::DynamicUndoEvent::Undo

virtual bool Undo(BackendDerivedClass &in_backend)=0

Called when the user asks to undo an action.

ak_wwise_plugin_host_undo_manager_v1

Host API to handle the plug-in's undo operations.

Definition: HostUndoManager.h:127

AK.Wwise::Plugin::CBaseInstanceGlue

PluginInfoGenerator: Associates an existing C Interface with a variable that can be used....

Definition: PluginInfoGenerator.h:104

ak_wwise_plugin_undo_group_id

int ak_wwise_plugin_undo_group_id

Unique identifier for a particular undo group. Useful to reopen an unapplied closed group session.

Definition: PluginDef.h:968

AK.Wwise::Plugin::AutoUndoGroup::m_reopenGroupId

ak_wwise_plugin_undo_group_id * m_reopenGroupId

Definition: HostUndoManager.h:733

AKASSERT

#define AKASSERT(Condition)

Definition: AkAssert.h:67

ak_wwise_plugin_undo_group_close_action

Action to apply once this undo group is closed.

Definition: PluginDef.h:994

ak_wwise_plugin_undo_event_v1::Destroy

void(* Destroy)(struct ak_wwise_plugin_undo_event_instance_v1 *in_this)

Called when the system needs to destroy your ak_wwise_plugin_undo_event_v1 instance.

Definition: HostUndoManager.h:72

AK.Wwise::Plugin::V1::DynamicUndoEvent::Interface::Interface

Interface()

The C interface, fulfilled by your plug-in.

Definition: HostUndoManager.h:412

AK.Wwise::Plugin::V1::UndoEvent

Base API to create a custom undo event in a plug-in.

Definition: HostUndoManager.h:328

ak_wwise_plugin_backend_instance

Plug-in backend instance.

Definition: PluginDef.h:556

AK.Wwise::Plugin::V1::BaseUndoEvent::GetInterfacePointer

virtual Interface * GetInterfacePointer()=0

AK.Wwise::Plugin::AutoUndoGroup::m_closeAction

ak_wwise_plugin_undo_group_close_action m_closeAction

Definition: HostUndoManager.h:735

AK.Wwise::Plugin::V1::DynamicUndoEvent

Definition: HostUndoManager.h:403

ak_wwise_plugin_host_undo_manager_v1::IsBusy

bool(* IsBusy)(const struct ak_wwise_plugin_host_undo_manager_instance_v1 *in_this)

Check if we are busy (undoing or redoing).

Definition: HostUndoManager.h:226

AK.Wwise::Plugin::V1::DynamicUndoEvent::Redo

virtual bool Redo(BackendDerivedClass &in_backend)=0

Called when the user asks to redo an action.

ak_wwise_plugin_host_undo_manager_v1::CloseGroup

bool(* CloseGroup)(struct ak_wwise_plugin_host_undo_manager_instance_v1 *in_this, ak_wwise_plugin_undo_group_close_action in_action, ak_wwise_plugin_undo_group_id in_groupId, const char *in_szApplyEventName)

Closes the last opened group, in stack ordering.

Definition: HostUndoManager.h:191

AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY_LAST_EVENT_NAME

@ AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY_LAST_EVENT_NAME

Same than AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY, but copies the name of the last inner undo e...

Definition: PluginDef.h:998

AK.Wwise::Plugin::InterfaceTypeValue

std::underlying_type< InterfaceType >::type InterfaceTypeValue

PluginInfoGenerator: Underlying storage type for the m_interface value in BaseInterface.

Definition: PluginInfoGenerator.h:49

AK.Wwise::Plugin::V1::RequestUndoManager

RequestedHostInterface< UndoManager > RequestUndoManager

Requests an UndoManager interface, provided as m_undoManager variable.

Definition: HostUndoManager.h:630

AK.Wwise::Plugin::V1::BaseUndoEvent::k_interfaceType

@ k_interfaceType

The interface type, as provided by this plug-in.

Definition: HostUndoManager.h:279

AK.Wwise::Plugin::V1::UndoEvent::Undo

virtual bool Undo(Backend &in_backend)=0

Called when the user asks to undo an action.

AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_CANCEL

@ AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_CANCEL

Close this group session permanently, and cancel all its internal operations. Undo operations are not...

Definition: PluginDef.h:999

AK.Wwise::Plugin::DynamicUndoEvent

V1::DynamicUndoEvent< BackendDerivedClass > DynamicUndoEvent

Latest version of the C++ DynamicUndoEvent template helper.

Definition: HostUndoManager.h:644

AK.Wwise::Plugin::AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_VERSION

AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_VERSION(AudioPlugin)

AK.Wwise::Plugin::AutoUndoGroup::DontApply

void DontApply()

Definition: HostUndoManager.h:718

AK.Wwise::Plugin::V1::DynamicUndoEvent::GetInterfacePointer

virtual BaseUndoEvent::Interface * GetInterfacePointer() final

Definition: HostUndoManager.h:449

AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_UNDO_MANAGER

@ AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_UNDO_MANAGER

2021.1 Undo Manager host service. ak_wwise_plugin_host_undo_manager_v1

Definition: PluginBaseInterface.h:81

AK.Wwise::Plugin::V1::BaseUndoEvent::BaseUndoEvent

BaseUndoEvent()

Definition: HostUndoManager.h:304

AK.Wwise::Plugin::V1::UndoManager::CanAddEvent

bool CanAddEvent() const

Check if we are currently in a state where we can add undo events.

Definition: HostUndoManager.h:592

ak_wwise_plugin_base_interface

Interface description and base class for every Wwise Authoring plug-in interface.

Definition: PluginBaseInterface.h:120

AK.Wwise::Plugin::V1::UndoEvent::GetInterfacePointer

virtual BaseUndoEvent::Interface * GetInterfacePointer() final

Definition: HostUndoManager.h:366

AK.Wwise::Plugin::V1::UndoEvent::Redo

virtual bool Redo(Backend &in_backend)=0

Called when the user asks to redo an action.

ak_wwise_plugin_undo_event_pair_v1

A definition of an undo event, with a specific interface and instance.

Definition: PluginDef.h:963

AK.Wwise::Plugin::AutoUndoGroup::IsValid

bool IsValid()

Definition: HostUndoManager.h:723

ak_wwise_plugin_host_undo_manager_v1::ak_wwise_plugin_host_undo_manager_v1

ak_wwise_plugin_host_undo_manager_v1()

Definition: HostUndoManager.h:136

AK.Wwise::Plugin::V1::UndoManager::IsBusy

bool IsBusy() const

Check if we are busy (undoing or redoing).

Definition: HostUndoManager.h:602

AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY_FIRST_EVENT_NAME

@ AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY_FIRST_EVENT_NAME

Same than AK_WWISE_PLUGIN_UNDO_GROUP_CLOSE_ACTION_APPLY, but copies the name of the first inner undo ...

Definition: PluginDef.h:997

AK.Wwise::Plugin::V1::UndoManager::OpenGroup

ak_wwise_plugin_undo_group_id OpenGroup(ak_wwise_plugin_undo_group_id in_reopenGroupId=0)

Open a group that will contain all subsequent undo events.

Definition: HostUndoManager.h:537

MKBOOL

#define MKBOOL(cond)

Definition: PluginHelpers.h:79

AK.Wwise::Plugin::RequestedHostInterface< UndoManager >

Definition: HostUndoManager.h:653

AK.Wwise::Plugin::V1::UndoManager::k_interfaceVersion

@ k_interfaceVersion

The interface version, as requested by this plug-in.

Definition: HostUndoManager.h:510

AK_WWISE_PLUGIN_SPECIALIZE_HOST_INTERFACE

#define AK_WWISE_PLUGIN_SPECIALIZE_HOST_INTERFACE(in_name, in_varname,...)

PluginInfoGenerator: Creates a C++ host specialization for interface class specified in in_name,...

Definition: PluginInfoGenerator.h:237

AK.Wwise::Plugin::V1::BaseUndoEvent::k_interfaceVersion

@ k_interfaceVersion

The interface version, as provided by this plug-in.

Definition: HostUndoManager.h:289

AK.Wwise::Plugin::AutoUndoGroup::m_groupId

ak_wwise_plugin_undo_group_id m_groupId

Definition: HostUndoManager.h:732

AK.Wwise::Plugin::V1::BaseUndoEvent::~BaseUndoEvent

virtual ~BaseUndoEvent()

Definition: HostUndoManager.h:309

AK.Wwise::Plugin::UndoManager

V1::UndoManager UndoManager

Latest version of the C++ UndoManager interface.

Definition: HostUndoManager.h:649

AK.Wwise::Plugin::AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_CLASS

AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_CLASS(AudioPlugin)

AK.Wwise::Plugin::UndoEvent

V1::UndoEvent< Backend > UndoEvent

Latest version of the C++ UndoEvent template helper.

Definition: HostUndoManager.h:641

AK.Wwise::Plugin::AutoUndoGroup::Cancel

void Cancel()

Definition: HostUndoManager.h:712

AK.Wwise::Plugin

Definition: AudioPlugin.h:111

Cette page a-t-elle été utile ?

Besoin d'aide ?

Des questions ? Des problèmes ? Besoin de plus d'informations ? Contactez-nous, nous pouvons vous aider !

Visitez notre page d'Aide

Décrivez-nous de votre projet. Nous sommes là pour vous aider.

Enregistrez votre projet et nous vous aiderons à démarrer sans aucune obligation !

Partir du bon pied avec Wwise