// Method to marshal from native to managed struct
        internal unsafe void __MarshalFrom(ref __Native @ref)
        {
            this.Size = @ref.Size;
            this.SizeImageInfo = @ref.SizeImageInfo;
            this.ViewCount = @ref.ViewCount;
            this.ButtonCount = @ref.ButtonCount;
            this.AxeCount = @ref.AxeCount;
            this.PovCount = @ref.PovCount;
            this.BufferSize = @ref.BufferSize;
            this.BufferUsed = @ref.BufferUsed;
            this.ImageInfoArrayPointer = @ref.ImageInfoArrayPointer;

            if (this.BufferSize > 0 && this.ImageInfoArrayPointer != IntPtr.Zero)
            {
                int nbImageInfoElements = BufferSize/ sizeof(DeviceImage.__Native);
                Images = new DeviceImage[nbImageInfoElements];
                var pImageInfo = (DeviceImage.__Native*)this.ImageInfoArrayPointer;
                for (int i = 0; i < Images.Length; i++)
                {
                    var image = new DeviceImage();
                    image.__MarshalFrom(ref *pImageInfo);
                    pImageInfo++;
                }
            }
        }

        // Method to marshal from native to managed struct
        internal unsafe void __MarshalFrom(ref __Native @ref)
        {
            this.FontFace = (@ref.FontFace == IntPtr.Zero) ? null : new FontFace(@ref.FontFace);
            // If FontFace != null, adds a reference to it
            if (FontFace != null)
                ((IUnknown) this.FontFace).AddReference();
            this.FontSize= @ref.FontEmSize;
            this.GlyphCount = @ref.GlyphCount;
            if (@ref.GlyphIndices != IntPtr.Zero)
            {
                Indices = new short[GlyphCount];
                if (GlyphCount > 0)
                    Utilities.Read(@ref.GlyphIndices, Indices, 0, GlyphCount);
            }

            if (@ref.GlyphAdvances != IntPtr.Zero)
            {
                Advances = new float[GlyphCount];
                if (GlyphCount > 0)
                    Utilities.Read(@ref.GlyphAdvances, Advances, 0, GlyphCount);
            }

            if (@ref.GlyphOffsets != IntPtr.Zero)
            {
                Offsets = new GlyphOffset[GlyphCount];
                if (GlyphCount > 0)
                    Utilities.Read(@ref.GlyphOffsets, Offsets, 0, GlyphCount);
            }
            this.IsSideways = @ref.IsSideways;
            this.BidiLevel = @ref.BidiLevel;
        }

 // Method to marshal from managed struct tot native
 internal unsafe void __MarshalTo(ref __Native @ref)
 {
     @ref.LocaleName = (this.LocaleName == null) ? IntPtr.Zero : Marshal.StringToHGlobalUni(this.LocaleName);
     @ref.Text = (this.Text == null) ? IntPtr.Zero : Marshal.StringToHGlobalUni(this.Text);
     @ref.TextLength = (this.Text == null)?0: this.Text.Length;
     @ref.ClusterMap = this.ClusterMap;
     @ref.TextPosition = this.TextPosition;
 }

 // Method to marshal from native to managed struct
 internal unsafe void __MarshalFrom(ref __Native @ref)
 {
     this.LocaleName = (@ref.LocaleName == IntPtr.Zero) ? null : Marshal.PtrToStringUni(@ref.LocaleName);
     this.Text = (@ref.Text == IntPtr.Zero) ? null : Marshal.PtrToStringUni(@ref.Text, @ref.TextLength);
     this.TextLength = @ref.TextLength;
     this.ClusterMap = @ref.ClusterMap;
     this.TextPosition = @ref.TextPosition;
 }

 // Method to marshal from native to managed struct
 internal unsafe void __MarshalFrom(__Native* @ref)
 {
     this.Format = null;
     this.FormatPointer = @ref->FormatPointer;
     if (this.FormatPointer != IntPtr.Zero)
         this.Format = WaveFormat.MarshalFrom(this.FormatPointer);
     this.MaxFrameCount = @ref->MaxFrameCount;
 }

 // Method to marshal from native to managed struct
 internal unsafe void __MarshalFrom(ref __Native @ref)
 {
     this.Category = @ref.Category;
     this.Severity = @ref.Severity;
     this.Id = @ref.Id;
     this.Description = (@ref.PDescription == IntPtr.Zero) ? null : Marshal.PtrToStringAnsi(@ref.PDescription, @ref.DescriptionByteLength);
     this.DescriptionByteLength = @ref.DescriptionByteLength;
 }

 internal void UpdateNative(ref __Native native, IntPtr pinBuffer)
 {
     native.Pointer = pinBuffer;
     if (managedData != null)
     {
         native.Size = managedData.Length;
     }
 }

 // Method to marshal from native to managed struct
 internal unsafe void __MarshalFrom(ref __Native @ref)
 {
     this.Size = @ref.Size;
     this.ObjectSize = @ref.ObjectSize;
     this.Flags = @ref.Flags;
     this.DataSize = @ref.DataSize;
     this.ObjectArrayCount = @ref.ObjectArrayCount;
     this.ObjectArrayPointer = @ref.ObjectArrayPointer;
 }

 // Method to marshal from native to managed struct
 internal unsafe void __MarshalFrom(ref __Native @ref)
 {
     this.AttribId = @ref.AttribId;
     this.FaceStart = @ref.FaceStart;
     this.FaceCount = @ref.FaceCount;
     this.VertexStart = @ref.VertexStart;
     this.VertexCount = @ref.VertexCount;
     this.BonedIdsPointer = @ref.BonedIdsPointer;
 }

        // Method to marshal from managed struct tot native
        internal unsafe void __MarshalTo(ref __Native @ref)
        {
            @ref.Size = this.Size;
            @ref.Flags = this.Flags;
            @ref.BufferBytes = this.BufferBytes;
            @ref.Reserved = this.Reserved;
            @ref.pFormat = WaveFormat.MarshalToPtr(Format);
            @ref.AlgorithmFor3D = this.AlgorithmFor3D;		
		}

 // Method to marshal from native to managed struct
 internal void __MarshalFrom(ref __Native @ref)
 {
     waveFormatTag = @ref.pcmWaveFormat.waveFormatTag;
     channels = @ref.pcmWaveFormat.channels;
     sampleRate = @ref.pcmWaveFormat.sampleRate;
     averageBytesPerSecond = @ref.pcmWaveFormat.averageBytesPerSecond;
     blockAlign = @ref.pcmWaveFormat.blockAlign;
     bitsPerSample = @ref.pcmWaveFormat.bitsPerSample;
     extraSize = @ref.extraSize;
 }

 // Method to marshal from native to managed struct
 internal unsafe void __MarshalFrom(ref __Native @ref)
 {
     this.waveFormatTag = @ref.pcmWaveFormat.waveFormatTag;
     this.channels = @ref.pcmWaveFormat.channels;
     this.sampleRate = @ref.pcmWaveFormat.sampleRate;
     this.averageBytesPerSecond = @ref.pcmWaveFormat.averageBytesPerSecond;
     this.blockAlign = @ref.pcmWaveFormat.blockAlign;
     this.bitsPerSample = @ref.pcmWaveFormat.bitsPerSample;
     this.extraSize = @ref.extraSize;            
 }

 // Method to marshal from native to managed struct
 internal unsafe void __MarshalFrom(ref __Native @ref)
 {
     this.Category = @ref.Category;
     this.Priority = @ref.Priority;
     this.Pitch = @ref.Pitch;
     this.Volume = @ref.Volume;
     this.TrackProperties = new TrackProperties[@ref.NumTracks];
     fixed (void* ptr = &@ref.TrackPropertiesPointer)
         Utilities.Read((IntPtr) ptr, this.TrackProperties, 0, @ref.NumTracks);
 }

 // Method to marshal from managed struct tot native
 internal void __MarshalTo(ref __Native @ref)
 {
     @ref.pcmWaveFormat.waveFormatTag = waveFormatTag;
     @ref.pcmWaveFormat.channels = channels;
     @ref.pcmWaveFormat.sampleRate = sampleRate;
     @ref.pcmWaveFormat.averageBytesPerSecond = averageBytesPerSecond;
     @ref.pcmWaveFormat.blockAlign = blockAlign;
     @ref.pcmWaveFormat.bitsPerSample = bitsPerSample;
     @ref.extraSize = extraSize;
 }

 // Method to marshal from managed struct tot native
 internal unsafe void __MarshalTo(ref __Native @ref)
 {
     @ref.AttribId = this.AttribId;
     @ref.FaceStart = this.FaceStart;
     @ref.FaceCount = this.FaceCount;
     @ref.VertexStart = this.VertexStart;
     @ref.VertexCount = this.VertexCount;
     @ref.BonedIdsPointer = IntPtr.Zero;
     if (BoneIds != null)
         @ref.BonedIdsPointer = Marshal.AllocHGlobal(BoneIds.Length*sizeof (int));
 }

 // Method to marshal from native to managed struct
 internal unsafe void __MarshalFrom(ref __Native @ref)
 {
     this.LpfDirectCoefficient = @ref.LPFDirectCoefficient;
     this.LpfReverbCoefficient = @ref.LPFReverbCoefficient;
     this.ReverbLevel = @ref.ReverbLevel;
     this.DopplerFactor = @ref.DopplerFactor;
     this.EmitterToListenerAngle = @ref.EmitterToListenerAngle;
     this.EmitterToListenerDistance = @ref.EmitterToListenerDistance;
     this.EmitterVelocityComponent = @ref.EmitterVelocityComponent;
     this.ListenerVelocityComponent = @ref.ListenerVelocityComponent;
 }

 // Method to marshal from managed struct tot native
 internal unsafe void __MarshalTo(ref __Native @ref)
 {
     @ref.EffectFilename = (this.EffectFilename == null) ? IntPtr.Zero : Marshal.StringToHGlobalAnsi(this.EffectFilename);
     var defaultsNative = (EffectDefault.__Native*)Marshal.AllocHGlobal(Defaults.Length * sizeof(EffectDefault.__Native));
     for (int i = 0; i < Defaults.Length; i++)
     {
         Defaults[i].__MarshalTo(ref defaultsNative[i]);
     }
     @ref.DefaultCount = Defaults.Length;
     @ref.DefaultPointer = (IntPtr)defaultsNative;
 }

 internal unsafe void __MarshalTo(ref __Native @ref)
 {
     @ref.FormatPointer = IntPtr.Zero;
     if (Format != null)
     {
         int sizeOfFormat = Marshal.SizeOf(Format);
         @ref.FormatPointer = Marshal.AllocCoTaskMem(sizeOfFormat);
         Marshal.StructureToPtr(Format, @ref.FormatPointer, false);
     }
     @ref.MaxFrameCount = this.MaxFrameCount;
 }

 // Method to marshal from native to managed struct
 internal unsafe void __MarshalFrom(ref __Native @ref)
 {
     this.EffectFilename = (@ref.EffectFilename == IntPtr.Zero) ? null : Marshal.PtrToStringAnsi(@ref.EffectFilename);
     var defaultsNative = new EffectDefault.__Native[@ref.DefaultCount];
     Utilities.Read(@ref.DefaultPointer, defaultsNative, 0, defaultsNative.Length);
     Defaults = new EffectDefault[defaultsNative.Length];
     for (int i = 0; i < Defaults.Length; i++)
     {
         Defaults[i] = new EffectDefault();
         Defaults[i].__MarshalFrom(ref defaultsNative[i]);
     }
 }

        // Method to marshal from native to managed struct
        internal unsafe void __MarshalFrom(ref __Native @ref)
        {
            this.Category = @ref.Category;
            this.Priority = @ref.Priority;
            this.Pitch = @ref.Pitch;
            this.Volume = @ref.Volume;
            this.TrackProperties = new TrackProperties[@ref.NumTracks];

            // if there are no tracks - don't read the properties, otherwise a IndexOutOfRangeException is thrown.
            if (@ref.NumTracks > 0)
            {
                fixed (void* ptr = &@ref.TrackPropertiesPointer)
                    Utilities.Read((IntPtr)ptr, this.TrackProperties, 0, @ref.NumTracks);
            }
        }