_host_data_writer_8h

Wwise SDK 2023.1.9

 /*******************************************************************************
 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 write data that can be converted for the target platform.
  * \file AK/Wwise/Plugin/HostDataWriter.h
  */
  
 #pragma once
  
 #include "PluginInfoGenerator.h"
  
 /**
  * \brief Interface used to write data during sound bank generation.
  * 
  * \aknote
  * All functions perform the appropriate platform-specific byte reordering, except where noted.
  * \endaknote
  * 
  * \sa
  * - \ref wwiseplugin_bank
  * - AK::Wwise::Plugin::Plugin::GetBankParameters()
  */
 struct ak_wwise_plugin_host_data_writer_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_data_writer_v1.
     using Instance = ak_wwise_plugin_host_data_writer_instance_v1;
  
     ak_wwise_plugin_host_data_writer_v1() :
         ak_wwise_plugin_base_interface(AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_DATA_WRITER, 1)
     {}
 #endif
  
     /**
      * \brief Writes a block of data.
      * 
      * \akcaution 
      * This data will always be written as-is, with no platform-specific conversion.
      * \endakcaution
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_pData A pointer to the buffer containing the data to be written.
      * \param[in] in_cBytes The number of bytes to write.
      * \param[out] out_cWritten The number of bytes actually written.
      * \return true if successful.
      */
     bool(*WriteData)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         const void* in_pData,
         uint32_t in_cBytes,
         uint32_t* out_cWritten
     );
  
     /**
      * \brief Writes a string.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_szString The string to be written (null-terminated).
      * \return true if successful.
      */
     bool(*WriteString)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         const char * in_szString
     );
  
     /**
      * \brief Writes a 64-bit signed integer value.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_value The value to be written.
      * \return true if successful.
      */
     bool(*WriteInt64)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         int64_t in_value
     );
  
     /**
      * \brief Writes a 32-bit signed integer value.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_value The value to be written.
      * \return true if successful.
      */
     bool(*WriteInt32)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         int32_t in_value
     );
  
     /**
      * \brief Writes a 16-bit signed integer value.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_value The value to be written.
      * \return true if successful.
      */
     bool(*WriteInt16)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         int16_t in_value
     );
  
     /**
      * \brief Writes an 8-bit signed integer value.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_value The value to be written.
      * \return true if successful.
      */
     bool(*WriteInt8)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         int8_t in_value
     );
  
     /**
      * \brief Writes a 64-bit unsigned integer value.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_value The value to be written.
      * \return true if successful.
      */
     bool(*WriteUInt64)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         uint64_t in_value
     );
  
     /**
      * \brief Writes a 32-bit unsigned integer value.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_value The value to be written.
      * \return true if successful.
      */
     bool(*WriteUInt32)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         uint32_t in_value
     );
  
     /**
      * \brief Writes a 16-bit unsigned integer value.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_value The value to be written.
      * \return true if successful.
      */
     bool(*WriteUInt16)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         uint16_t in_value
     );
  
     /**
      * \brief Writes an 8-bit unsigned integer value.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_value The value to be written.
      * \return true if successful.
      */
     bool(*WriteUInt8)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         uint8_t in_value
     );
  
     /**
      * \brief Writes a 64-bit, double-precision floating point value.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_value The value to be written.
      * \return true if successful.
      */
     bool(*WriteReal64)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         double in_value
     );
  
     /**
      * \brief Writes a 32-bit, single-precision floating point value.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_value The value to be written.
      * \return true if successful.
      */
     bool(*WriteReal32)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         float in_value
     );
  
     /**
      * \brief Writes a boolean value.
      * 
      * \param[in] in_this Current instance of this interface.
      * \param[in] in_value The boolean to be written.
      * \return true if successful.
      */
     bool(*WriteBool)(
         struct ak_wwise_plugin_host_data_writer_instance_v1* in_this,
         bool in_value
     );
 };
 #define AK_WWISE_PLUGIN_HOST_WRITE_V1_ID() \
     AK_WWISE_PLUGIN_BASE_INTERFACE_FROM_ID(AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_DATA_WRITER, 1)
 #define AK_WWISE_PLUGIN_HOST_WRITE_V1_CTOR() \
 { \
     .m_baseInterface = AK_WWISE_PLUGIN_HOST_WRITE_V1_ID() \
 }
  
 #ifdef __cplusplus
 namespace AK::Wwise::Plugin
 {
     namespace V1
     {
         using CHostDataWriter = ak_wwise_plugin_host_data_writer_v1;
         
         /// \copydoc ak_wwise_plugin_host_data_writer_v1
         class DataWriter : public CBaseInstanceGlue<CHostDataWriter>
         {
         public:
             using Interface = CHostDataWriter;
  
             /**
              * \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_DATA_WRITER
             };
             /**
              * \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 Writes a block of data.
              * 
              * \akcaution 
              * This data will always be written as-is, with no platform-specific conversion.
              * \endakcaution
              * 
              * \param[in] in_pData A pointer to the buffer containing the data to be written.
              * \param[in] in_cBytes The number of bytes to write.
              * \param[out] out_cWritten The number of bytes actually written.
              * \return true if successful.
              */
             inline bool WriteData(
                 const void* in_pData,
                 uint32_t in_cBytes,
                 uint32_t& out_cWritten
             )
             {
                 return MKBOOL(g_cinterface->WriteData(this, in_pData, in_cBytes, &out_cWritten));
             }
  
             /**
              * \brief Writes a string.
              * 
              * \param[in] in_szString The string to be written (null-terminated).
              * \return true if successful.
              */
             inline bool WriteString(
                 const char * in_szString
             )
             {
                 return MKBOOL(g_cinterface->WriteString(this, in_szString));
             }
  
             /**
              * \brief Writes a 64-bit signed integer value.
              * 
              * \param[in] in_value The value to be written.
              * \return true if successful.
              */
             inline bool WriteInt64(
                 int64_t in_value
             )
             {
                 return MKBOOL(g_cinterface->WriteInt64(this, in_value));
             }
  
             /**
              * \brief Writes a 32-bit signed integer value.
              * 
              * \param[in] in_value The value to be written.
              * \return true if successful.
              */
             inline bool WriteInt32(
                 int32_t in_value
             )
             {
                 return MKBOOL(g_cinterface->WriteInt32(this, in_value));
             }
  
             /**
              * \brief Writes a 16-bit signed integer value.
              * 
              * \param[in] in_value The value to be written.
              * \return true if successful.
              */
             inline bool WriteInt16(
                 int16_t in_value
             )
             {
                 return MKBOOL(g_cinterface->WriteInt16(this, in_value));
             }
  
             /**
              * \brief Writes an 8-bit signed integer value.
              * 
              * \param[in] in_value The value to be written.
              * \return true if successful.
              */
             inline bool WriteInt8(
                 int8_t in_value
             )
             {
                 return MKBOOL(g_cinterface->WriteInt8(this, in_value));
             }
  
             /**
              * \brief Writes a 64-bit unsigned integer value.
              * 
              * \param[in] in_value The value to be written.
              * \return true if successful.
              */
             inline bool WriteUInt64(
                 uint64_t in_value
             )
             {
                 return MKBOOL(g_cinterface->WriteUInt64(this, in_value));
             }
  
             /**
              * \brief Writes a 32-bit unsigned integer value.
              * 
              * \param[in] in_value The value to be written.
              * \return true if successful.
              */
             inline bool WriteUInt32(
                 uint32_t in_value
             )
             {
                 return MKBOOL(g_cinterface->WriteUInt32(this, in_value));
             }
  
             /**
              * \brief Writes a 16-bit unsigned integer value.
              * 
              * \param[in] in_value The value to be written.
              * \return true if successful.
              */
             inline bool WriteUInt16(
                 uint16_t in_value
             )
             {
                 return MKBOOL(g_cinterface->WriteUInt16(this, in_value));
             }
  
             /**
              * \brief Writes an 8-bit unsigned integer value.
              * 
              * \param[in] in_value The value to be written.
              * \return true if successful.
              */
             inline bool WriteUInt8(
                 uint8_t in_value
             )
             {
                 return MKBOOL(g_cinterface->WriteUInt8(this, in_value));
             }
  
             /**
              * \brief Writes a 64-bit, double-precision floating point value.
              * 
              * \param[in] in_value The value to be written.
              * \return true if successful.
              */
             inline bool WriteReal64(
                 double in_value
             )
             {
                 return MKBOOL(g_cinterface->WriteReal64(this, in_value));
             }
  
             /**
              * \brief Writes a 32-bit, single-precision floating point value.
              * 
              * \param[in] in_value The value to be written.
              * \return true if successful.
              */
             inline bool WriteReal32(
                 float in_value
             )
             {
                 return MKBOOL(g_cinterface->WriteReal32(this, in_value));
             }
  
             /**
              * \brief Writes a boolean value.
              * 
              * \param[in] in_value The boolean to be written.
              * \return true if successful.
              */
             inline bool WriteBool(
                 bool in_value
             )
             {
                 return MKBOOL(g_cinterface->WriteBool(this, in_value));
             }
         };
  
         /**
          * \brief Requests a DataWriter interface.
          * 
          * Deriving your plug-in class from RequestConversionHelpers will automatically request
          * DataWriter interface. This is useful for SoundBank generation and parameter
          * passing to the Sound Engine. You must derive from this interface in order to use the
          * provided functions.
          * 
          * \aknote The AK::Wwise::Plugin::RequestPropertySet and AK::Wwise::Plugin::RequestWrite classes are
          * automatically derived when providing AK::Wwise::Plugin::AudioPlugin in C++. \endaknote
          */
         using RequestWrite = RequestedHostInterface<DataWriter>;
  
     } // of namespace V1
  
     /// Latest version of the C DataWriter interface.
     using CHostDataWriter = V1::CHostDataWriter;
     /// Latest version of the C++ DataWriter interface.
     using DataWriter = V1::DataWriter;
     /// Latest version of the requested C++ DataWriter interface.
     using RequestWrite = V1::RequestWrite;
  
     AK_WWISE_PLUGIN_SPECIALIZE_HOST_INTERFACE_NO_BASE_INSTANCE(DataWriter, dataWriter);
     AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_CLASS(DataWriter);
     AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_VERSION(DataWriter);
 } // of namespace AK::Wwise::Plugin
  
 #endif

ak_wwise_plugin_host_data_writer_v1

Interface used to write data during sound bank generation.

Definition: HostDataWriter.h:51

AK.Wwise::Plugin::V1::DataWriter::k_interfaceType

@ k_interfaceType

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

Definition: HostDataWriter.h:257

AK.Wwise::Plugin::V1::DataWriter

Interface used to write data during sound bank generation.

Definition: HostDataWriter.h:245

AK.Wwise::Plugin::V1::DataWriter::WriteInt64

bool WriteInt64(int64_t in_value)

Writes a 64-bit signed integer value.

Definition: HostDataWriter.h:310

AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_DATA_WRITER

@ AK_WWISE_PLUGIN_INTERFACE_TYPE_HOST_DATA_WRITER

2021.1 Data Writer host service. ak_wwise_plugin_host_data_writer_v1

Definition: PluginBaseInterface.h:82

ak_wwise_plugin_host_data_writer_v1::WriteInt8

bool(* WriteInt8)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, int8_t in_value)

Writes an 8-bit signed integer value.

Definition: HostDataWriter.h:140

AK.Wwise::Plugin::CBaseInterfaceGlue< CHostDataWriter >::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_host_data_writer_v1::WriteReal64

bool(* WriteReal64)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, double in_value)

Writes a 64-bit, double-precision floating point value.

Definition: HostDataWriter.h:200

AK.Wwise::Plugin::V1::DataWriter::WriteData

bool WriteData(const void *in_pData, uint32_t in_cBytes, uint32_t &out_cWritten)

Writes a block of data.

Definition: HostDataWriter.h:282

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::V1::DataWriter::WriteReal64

bool WriteReal64(double in_value)

Writes a 64-bit, double-precision floating point value.

Definition: HostDataWriter.h:414

ak_wwise_plugin_host_data_writer_v1::WriteInt32

bool(* WriteInt32)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, int32_t in_value)

Writes a 32-bit signed integer value.

Definition: HostDataWriter.h:116

ak_wwise_plugin_host_data_writer_v1::WriteUInt16

bool(* WriteUInt16)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, uint16_t in_value)

Writes a 16-bit unsigned integer value.

Definition: HostDataWriter.h:176

AK.Wwise::Plugin::V1::DataWriter::WriteReal32

bool WriteReal32(float in_value)

Writes a 32-bit, single-precision floating point value.

Definition: HostDataWriter.h:427

AK.Wwise::Plugin::DataWriter

V1::DataWriter DataWriter

Latest version of the C++ DataWriter interface.

Definition: HostDataWriter.h:466

ak_wwise_plugin_host_data_writer_instance_v1

Base host-provided instance type for ak_wwise_plugin_host_data_writer_v1.

Definition: PluginDef.h:633

ak_wwise_plugin_host_data_writer_v1::WriteInt64

bool(* WriteInt64)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, int64_t in_value)

Writes a 64-bit signed integer value.

Definition: HostDataWriter.h:104

ak_wwise_plugin_host_data_writer_v1::WriteReal32

bool(* WriteReal32)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, float in_value)

Writes a 32-bit, single-precision floating point value.

Definition: HostDataWriter.h:212

ak_wwise_plugin_host_data_writer_v1::WriteUInt8

bool(* WriteUInt8)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, uint8_t in_value)

Writes an 8-bit unsigned integer value.

Definition: HostDataWriter.h:188

AK.Wwise::Plugin::V1::DataWriter::WriteInt8

bool WriteInt8(int8_t in_value)

Writes an 8-bit signed integer value.

Definition: HostDataWriter.h:349

AK.Wwise::Plugin::V1::CHostDataWriter

ak_wwise_plugin_host_data_writer_v1 CHostDataWriter

Definition: HostDataWriter.h:241

PluginInfoGenerator.h

Wwise Authoring Plug-ins - C++ class helper to automatically determine the plug-in interfaces used in...

AK.Wwise::Plugin::CBaseInstanceGlue

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

Definition: PluginInfoGenerator.h:104

AK.Wwise::Plugin::V1::DataWriter::WriteString

bool WriteString(const char *in_szString)

Writes a string.

Definition: HostDataWriter.h:297

AK.Wwise::Plugin::V1::DataWriter::WriteInt32

bool WriteInt32(int32_t in_value)

Writes a 32-bit signed integer value.

Definition: HostDataWriter.h:323

AK.Wwise::Plugin::V1::DataWriter::WriteUInt64

bool WriteUInt64(uint64_t in_value)

Writes a 64-bit unsigned integer value.

Definition: HostDataWriter.h:362

AK.Wwise::Plugin::V1::DataWriter::WriteInt16

bool WriteInt16(int16_t in_value)

Writes a 16-bit signed integer value.

Definition: HostDataWriter.h:336

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_host_data_writer_v1::WriteString

bool(* WriteString)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, const char *in_szString)

Writes a string.

Definition: HostDataWriter.h:92

AK.Wwise::Plugin::V1::DataWriter::WriteBool

bool WriteBool(bool in_value)

Writes a boolean value.

Definition: HostDataWriter.h:440

AK.Wwise::Plugin::AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_VERSION

AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_VERSION(AudioPlugin)

AK_WWISE_PLUGIN_SPECIALIZE_HOST_INTERFACE_NO_BASE_INSTANCE

#define AK_WWISE_PLUGIN_SPECIALIZE_HOST_INTERFACE_NO_BASE_INSTANCE(in_name, in_varname)

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

Definition: PluginInfoGenerator.h:262

AK.Wwise::Plugin::V1::DataWriter::k_interfaceVersion

@ k_interfaceVersion

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

Definition: HostDataWriter.h:267

ak_wwise_plugin_host_data_writer_v1::WriteBool

bool(* WriteBool)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, bool in_value)

Writes a boolean value.

Definition: HostDataWriter.h:224

ak_wwise_plugin_host_data_writer_v1::ak_wwise_plugin_host_data_writer_v1

ak_wwise_plugin_host_data_writer_v1()

Definition: HostDataWriter.h:60

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::DataWriter::WriteUInt16

bool WriteUInt16(uint16_t in_value)

Writes a 16-bit unsigned integer value.

Definition: HostDataWriter.h:388

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

Definition: HostDataWriter.h:470

MKBOOL

#define MKBOOL(cond)

Definition: PluginHelpers.h:74

AK.Wwise::Plugin::V1::RequestWrite

RequestedHostInterface< DataWriter > RequestWrite

Requests a DataWriter interface.

Definition: HostDataWriter.h:459

ak_wwise_plugin_host_data_writer_v1::WriteInt16

bool(* WriteInt16)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, int16_t in_value)

Writes a 16-bit signed integer value.

Definition: HostDataWriter.h:128

AK.Wwise::Plugin::V1::DataWriter::WriteUInt8

bool WriteUInt8(uint8_t in_value)

Writes an 8-bit unsigned integer value.

Definition: HostDataWriter.h:401

ak_wwise_plugin_host_data_writer_v1::WriteUInt32

bool(* WriteUInt32)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, uint32_t in_value)

Writes a 32-bit unsigned integer value.

Definition: HostDataWriter.h:164

AK.Wwise::Plugin::AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_CLASS

AK_WWISE_PLUGIN_SPECIALIZE_INTERFACE_CLASS(AudioPlugin)

AK.Wwise::Plugin::V1::DataWriter::WriteUInt32

bool WriteUInt32(uint32_t in_value)

Writes a 32-bit unsigned integer value.

Definition: HostDataWriter.h:375

ak_wwise_plugin_host_data_writer_v1::WriteUInt64

bool(* WriteUInt64)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, uint64_t in_value)

Writes a 64-bit unsigned integer value.

Definition: HostDataWriter.h:152

AK.Wwise::Plugin

Definition: AudioPlugin.h:111

ak_wwise_plugin_host_data_writer_v1::WriteData

bool(* WriteData)(struct ak_wwise_plugin_host_data_writer_instance_v1 *in_this, const void *in_pData, uint32_t in_cBytes, uint32_t *out_cWritten)

Writes a block of data.

Definition: HostDataWriter.h:78

Was this page helpful?

Need Support?

Questions? Problems? Need more info? Contact us, and we can help!

Visit our Support page

Tell us about your project. We're here to help.

Get started with Wwise

Wwise SDK