public static unsafe void CalliStdCallvoid0(void *thisObject, int param0, void *param1, int param2, void *param3, SharpDX.Mathematics.Interop.RawBool param4, void *methodPtr)
{
throw null;
}
/// <summary>
/// <p>Turn multithreading on or off.</p>
/// </summary>
/// <param name = "bMTProtect"><dd> <p>True to turn multithreading on, false to turn it off.</p> </dd></param>
/// <returns><p>True if multithreading was turned on prior to calling this method, false otherwise.</p></returns>
/// <doc-id>bb173820</doc-id>
/// <unmanaged>BOOL ID3D10Multithread::SetMultithreadProtected([In] BOOL bMTProtect)</unmanaged>
/// <unmanaged-short>ID3D10Multithread::SetMultithreadProtected</unmanaged-short>
public unsafe SharpDX.Mathematics.Interop.RawBool SetMultithreadProtected(SharpDX.Mathematics.Interop.RawBool bMTProtect)
{
SharpDX.Mathematics.Interop.RawBool __result__;
__result__ = SharpDX.LocalInterop.CalliStdCallSharpDXMathematicsInteropRawBool0(this._nativePointer, bMTProtect, (*(void ***)this._nativePointer)[5]);
return(__result__);
}
public static unsafe SharpDX.Mathematics.Interop.RawBool CalliSharpDXMathematicsInteropRawBool14(void *thisObject, SharpDX.Mathematics.Interop.RawBool arg0, void *methodPtr)
{
throw new NotImplementedException();
}
public static unsafe SharpDX.Mathematics.Interop.RawBool CalliFuncSharpDXMathematicsInteropRawBool125(SharpDX.Mathematics.Interop.RawBool arg0, void *funcPtr)
{
throw new NotImplementedException();
}
/// <summary>
/// <p>Sets the reporting state of XInput.</p>
/// </summary>
/// <param name="enable"><dd> <p>If enable is <strong><see cref="SharpDX.Result.False"/></strong>, XInput will only send neutral data in response to <strong><see cref="SharpDX.XInput.XInput.XInputGetState"/></strong> (all buttons up, axes centered, and triggers at 0). <strong><see cref="SharpDX.XInput.XInput.XInputSetState"/></strong> calls will be registered but not sent to the device. Sending any value other than <strong><see cref="SharpDX.Result.False"/> </strong>will restore reading and writing functionality to normal.</p> </dd></param>
/// <remarks>
/// <p>This function is meant to be called when an application gains or loses focus (such as via WM_ACTIVATEAPP). Using this function, you will not have to change the XInput query loop in your application as neutral data will always be reported if XInput is disabled. </p><p>In a controller that supports vibration effects: </p><ul> <li>Passing <strong><see cref="SharpDX.Result.False"/></strong> will stop any vibration effects currently playing. In this state, calls to <strong><see cref="SharpDX.XInput.XInput.XInputSetState"/></strong> will be registered, but not passed to the device.</li> <li>Passing <strong>TRUE</strong> will pass the last vibration request (even if it is 0) sent to <strong><see cref="SharpDX.XInput.XInput.XInputSetState"/></strong> to the device.</li> </ul>
/// </remarks>
/// <include file='.\..\Documentation\CodeComments.xml' path="/comments/comment[@id='XInputEnable']/*"/>
/// <msdn-id>microsoft.directx_sdk.reference.xinputenable</msdn-id>
/// <unmanaged>void XInputEnable([In] BOOL enable)</unmanaged>
/// <unmanaged-short>XInputEnable</unmanaged-short>
public static void XInputEnable(SharpDX.Mathematics.Interop.RawBool enable)
{
unsafe {
XInputEnable_(enable);
}
}
public static unsafe void CalliStdCallFuncvoid0(SharpDX.Mathematics.Interop.RawBool param0, void *funcPtr)
{
throw null;
}
private async Task ShowVideoAsync(MF.MediaSource mediaSource)
{
MF.Topology topology;
MF.PresentationDescriptor presentationDescriptor;
bool containsVideoStream = false;
bool containsAudioStream = false;
lock (m_mfResourceLock)
{
// Create topology
MF.MediaFactory.CreateTopology(out topology);
mediaSource.CreatePresentationDescriptor(out presentationDescriptor);
int streamDescriptorCount = presentationDescriptor.StreamDescriptorCount;
for (int loop = 0; loop < streamDescriptorCount; loop++)
{
SharpDX.Mathematics.Interop.RawBool selected = false;
MF.StreamDescriptor streamDescriptor;
presentationDescriptor.GetStreamDescriptorByIndex(loop, out selected, out streamDescriptor);
if (selected)
{
// Create source node
MF.TopologyNode sourceNode = null;
MF.MediaFactory.CreateTopologyNode(MF.TopologyType.SourceStreamNode, out sourceNode);
sourceNode.Set(MF.TopologyNodeAttributeKeys.Source, mediaSource);
sourceNode.Set(MF.TopologyNodeAttributeKeys.PresentationDescriptor, presentationDescriptor);
sourceNode.Set(MF.TopologyNodeAttributeKeys.StreamDescriptor, streamDescriptor);
// Create output node
MF.TopologyNode outputNode = null;
MF.MediaTypeHandler mediaTypeHandler = streamDescriptor.MediaTypeHandler;
Guid majorType = mediaTypeHandler.MajorType;
MF.MediaFactory.CreateTopologyNode(MF.TopologyType.OutputNode, out outputNode);
if (MF.MediaTypeGuids.Audio == majorType)
{
containsAudioStream = true;
MF.Activate audioRenderer;
MF.MediaFactory.CreateAudioRendererActivate(out audioRenderer);
outputNode.Object = audioRenderer;
GraphicsHelper.SafeDispose(ref audioRenderer);
}
else if (MF.MediaTypeGuids.Video == majorType)
{
if (m_targetControl == null)
{
throw new SeeingSharpException("Unable to display vido when MediaPlayerComponent is not bound to a target control!");
}
containsVideoStream = true;
MF.Activate videoRenderer;
MF.MediaFactory.CreateVideoRendererActivate(
m_targetControl.Handle,
out videoRenderer);
outputNode.Object = videoRenderer;
GraphicsHelper.SafeDispose(ref videoRenderer);
}
// Append nodes to topology
topology.AddNode(sourceNode);
topology.AddNode(outputNode);
sourceNode.ConnectOutput(0, outputNode, 0);
// Clear COM references
GraphicsHelper.SafeDispose(ref sourceNode);
GraphicsHelper.SafeDispose(ref outputNode);
GraphicsHelper.SafeDispose(ref mediaTypeHandler);
}
// Clear COM references
GraphicsHelper.SafeDispose(ref streamDescriptor);
}
// Get the total duration of the video
long durationLong = 0;
try
{
durationLong = presentationDescriptor.Get <long>(MF.PresentationDescriptionAttributeKeys.Duration);
m_currentVideoDuration = TimeSpan.FromTicks(durationLong);
}
catch (SharpDX.SharpDXException)
{
m_currentVideoDuration = TimeSpan.MaxValue;
}
}
// Dispose reference to the presentation descriptor
GraphicsHelper.SafeDispose(ref presentationDescriptor);
// Apply build topology to the session
Task <MF.MediaEvent> topologyReadyWaiter = m_sessionEventHandler.WaitForEventAsync(
MF.MediaEventTypes.SessionTopologyStatus,
(eventData) => eventData.Get <MF.TopologyStatus>(MF.EventAttributeKeys.TopologyStatus) == MF.TopologyStatus.Ready,
CancellationToken.None);
m_mediaSession.SetTopology(MF.SessionSetTopologyFlags.None, topology);
await topologyReadyWaiter;
// Clear reference to the topology
GraphicsHelper.SafeDispose(ref topology);
lock (m_mfResourceLock)
{
using (MF.ServiceProvider serviceProvider = m_mediaSession.QueryInterface <MF.ServiceProvider>())
{
// Query for display control service
if (containsVideoStream)
{
m_displayControl = serviceProvider.GetService <MF.VideoDisplayControl>(
new Guid("{0x1092a86c, 0xab1a, 0x459a,{0xa3, 0x36, 0x83, 0x1f, 0xbc, 0x4d, 0x11, 0xff}}"));
}
// Query for volume control service
if (containsAudioStream)
{
m_audioStreamVolume = serviceProvider.GetService <MF.AudioStreamVolume>(
MF.MediaServiceKeys.StreamVolume);
// Set initial volume
this.AudioVolume = m_audioVolume;
}
}
}
// Start playing the video
await StartSessionInternalAsync(true);
}
public static unsafe int Calliint180(void *thisObject, int arg0, int arg1, int arg2, System.Byte arg3, SharpDX.Mathematics.Interop.RawBool arg4, SharpDX.Mathematics.Interop.RawBool arg5, void *methodPtr)
{
throw new NotImplementedException();
}
/// <summary>
/// <p>Creates a new composition surface object that can be bound to a
/// Microsoft DirectX swap chain or swap buffer and associated
/// with a visual.</p>
/// </summary>
/// <param name="visual"><dd> <p>The requested access to the composition surface object. It can be one of the following values:</p> <table> <tr><th>Value</th><th>Meaning</th></tr> <tr><td><dl> <dt><strong></strong></dt> <dt>0x0000L</dt> </dl> </td><td> <p>No access.</p> </td></tr> <tr><td><dl> <dt><strong>COMPOSITIONSURFACE_READ</strong></dt> <dt>0x0001L</dt> </dl> </td><td> <p>Read access. For internal use only.</p> </td></tr> <tr><td><dl> <dt><strong>COMPOSITIONSURFACE_WRITE</strong></dt> <dt>0x0002L</dt> </dl> </td><td> <p>Write access. For internal use only.</p> </td></tr> <tr><td><dl> <dt><strong>COMPOSITIONSURFACE_ALL_ACCESS</strong></dt> <dt>0x0003L</dt> </dl> </td><td> <p>Read/write access. Always specify this flag except when duplicating a surface in another process, in which case set <em>desiredAccess</em> to 0.</p> </td></tr> </table> <p>?</p> </dd></param>
/// <param name="hwnd"><dd> <p>Contains the security descriptor for the composition surface object, and specifies whether the handle of the composition surface object is inheritable when a child process is created. If this parameter is <c>null</c>, the composition surface object is created with default security attributes that grant read and write access to the current process, but do not enable child processes to inherit the handle.</p> </dd></param>
/// <param name="enable"><dd> <p>The handle of the new composition surface object. This parameter must not be <c>null</c>.</p> </dd></param>
/// <returns><p>If the function succeeds, it returns <see cref="SharpDX.Result.Ok"/>. Otherwise, it returns an <strong><see cref="SharpDX.Result"/></strong> error code. See DirectComposition Error Codes for a list of error codes. </p></returns>
/// <include file='.\..\Documentation\CodeComments.xml' path="/comments/comment[@id='DCompositionAttachMouseWheelToHwnd']/*"/>
/// <msdn-id>hh437360</msdn-id>
/// <unmanaged>HRESULT DCompositionAttachMouseWheelToHwnd([In] IDCompositionVisual* visual,[In] HWND hwnd,[In] BOOL enable)</unmanaged>
/// <unmanaged-short>DCompositionAttachMouseWheelToHwnd</unmanaged-short>
internal static void AttachMouseWheelToHwnd(SharpDX.DirectComposition.Visual visual, System.IntPtr hwnd, SharpDX.Mathematics.Interop.RawBool enable)
{
unsafe {
SharpDX.Result __result__;
__result__ =
DCompositionAttachMouseWheelToHwnd_((void *)((visual == null)?IntPtr.Zero:visual.NativePointer), (void *)hwnd, enable);
__result__.CheckError();
}
}
private unsafe static extern int DCompositionAttachMouseWheelToHwnd_(void *arg0, void *arg1, SharpDX.Mathematics.Interop.RawBool arg2);
public static unsafe void CalliStdCallvoid0(void *thisObject, System.Guid param0, SharpDX.Mathematics.Interop.RawBool param1, void *methodPtr)
{
throw null;
}
/// <summary>
/// <p>Gets a literal status of a parameter. A literal parameter has a value that doesn't change during the lifetime of an effect.</p>
/// </summary>
/// <param name="hParameter"><dd> <p>Unique identifier to a parameter. See Handles (Direct3D 9).</p> </dd></param>
/// <returns><dd> <p>Returns True if the parameter is a literal, and False otherwise.</p> </dd></returns>
/// <remarks>
/// <p>This methods only changes whether the parameter is a literal or not. To change the value of a parameter, use a method like <strong><see cref="SharpDX.Direct3D9.BaseEffect.SetBool"/></strong> or <strong><see cref="SharpDX.Direct3D9.BaseEffect.SetValue"/></strong>.</p>
/// </remarks>
/// <include file='.\..\Documentation\CodeComments.xml' path="/comments/comment[@id='ID3DXEffectCompiler::GetLiteral']/*"/>
/// <msdn-id>bb205792</msdn-id>
/// <unmanaged>HRESULT ID3DXEffectCompiler::GetLiteral([In] D3DXHANDLE hParameter,[Out] BOOL* pLiteral)</unmanaged>
/// <unmanaged-short>ID3DXEffectCompiler::GetLiteral</unmanaged-short>
public SharpDX.Mathematics.Interop.RawBool GetLiteral(SharpDX.Direct3D9.EffectHandle hParameter) {
unsafe {
var hParameter_ = new SharpDX.Direct3D9.EffectHandle.__Native();
SharpDX.Direct3D9.EffectHandle.__MarshalTo(ref hParameter, ref hParameter_);
SharpDX.Mathematics.Interop.RawBool literalRef;
literalRef = new SharpDX.Mathematics.Interop.RawBool();
SharpDX.Result __result__;
__result__=
SharpDX.Direct3D9.LocalInterop.Calliint(_nativePointer, hParameter_, &literalRef,((void**)(*(void**)_nativePointer))[58]);
SharpDX.Direct3D9.EffectHandle.__MarshalFree(ref hParameter, ref hParameter_);
__result__.CheckError();
return literalRef;
}
}
/// <summary>
/// <p>Retrieves the activity status - enabled or disabled - for a set of lighting parameters within a device.</p>
/// </summary>
/// <param name="index"><dd> <p>Zero-based index of the set of lighting parameters that are the target of this method. </p> </dd></param>
/// <returns><dd> <p>Pointer to a variable to fill with the status of the specified lighting parameters. After the call, a nonzero value at this address indicates that the specified lighting parameters are enabled; a value of 0 indicates that they are disabled. </p> </dd></returns>
/// <remarks>
/// <p>This method will not return device state for a device that is created using <see cref="SharpDX.Direct3D9.CreateFlags.PureDevice"/>. If you want to use this method, you must create your device with any of the other values in <see cref="SharpDX.Direct3D9.CreateFlags"/>. </p>
/// </remarks>
/// <include file='.\..\Documentation\CodeComments.xml' path="/comments/comment[@id='IDirect3DDevice9::GetLightEnable']/*"/>
/// <msdn-id>bb174393</msdn-id>
/// <unmanaged>HRESULT IDirect3DDevice9::GetLightEnable([In] unsigned int Index,[Out] BOOL* pEnable)</unmanaged>
/// <unmanaged-short>IDirect3DDevice9::GetLightEnable</unmanaged-short>
public SharpDX.Mathematics.Interop.RawBool IsLightEnabled(int index) {
unsafe {
SharpDX.Mathematics.Interop.RawBool enableRef;
enableRef = new SharpDX.Mathematics.Interop.RawBool();
SharpDX.Result __result__;
__result__=
SharpDX.Direct3D9.LocalInterop.Calliint(_nativePointer, index, &enableRef,((void**)(*(void**)_nativePointer))[54]);
__result__.CheckError();
return enableRef;
}
}
/// <summary>
/// <p>Gets a <see cref="SharpDX.Mathematics.Interop.RawBool"/> value.</p>
/// </summary>
/// <param name="hParameter"><dd> <p>Unique identifier. See Handles (Direct3D 9).</p> </dd></param>
/// <param name="bRef"><dd> <p>Returns a Boolean value.</p> </dd></param>
/// <returns><p>If the method succeeds, the return value is <see cref="SharpDX.Direct3D9.ResultCode.Success"/>. If the method fails, the return value can be <see cref="SharpDX.Direct3D9.ResultCode.InvalidCall"/>.</p></returns>
/// <include file='.\..\Documentation\CodeComments.xml' path="/comments/comment[@id='ID3DXBaseEffect::GetBool']/*"/>
/// <msdn-id>bb205679</msdn-id>
/// <unmanaged>HRESULT ID3DXBaseEffect::GetBool([In] D3DXHANDLE hParameter,[Out] BOOL* pb)</unmanaged>
/// <unmanaged-short>ID3DXBaseEffect::GetBool</unmanaged-short>
internal void GetBool(SharpDX.Direct3D9.EffectHandle hParameter, out SharpDX.Mathematics.Interop.RawBool bRef) {
unsafe {
var hParameter_ = new SharpDX.Direct3D9.EffectHandle.__Native();
SharpDX.Direct3D9.EffectHandle.__MarshalTo(ref hParameter, ref hParameter_);
bRef = new SharpDX.Mathematics.Interop.RawBool();
SharpDX.Result __result__;
fixed (void* bRef_ = &bRef)
__result__=
SharpDX.Direct3D9.LocalInterop.Calliint(_nativePointer, hParameter_, bRef_,((void**)(*(void**)_nativePointer))[23]);
SharpDX.Direct3D9.EffectHandle.__MarshalFree(ref hParameter, ref hParameter_);
__result__.CheckError();
}
}
/// <summary>
/// <p>Runs the XAPO's digital signal processing (DSP) code on the given input and output buffers.</p>
/// </summary>
/// <param name = "inputProcessParameterCount"><dd> <p> Number of elements in pInputProcessParameters. </p> <strong>Note</strong>??XAudio2 currently supports only one input stream and one output stream. ? </dd></param>
/// <param name = "inputProcessParametersRef"><dd> <p> Input array of <strong><see cref = "SharpDX.XAPO.BufferParameters"/></strong> structures. </p> </dd></param>
/// <param name = "outputProcessParameterCount"><dd> <p>Number of elements in <em>pOutputProcessParameters</em>. </p> <strong>Note</strong>??XAudio2 currently supports only one input stream and one output stream. ? </dd></param>
/// <param name = "outputProcessParametersRef"><dd> <p>Output array of <strong><see cref = "SharpDX.XAPO.BufferParameters"/></strong> structures. On input, the value of <strong><see cref = "SharpDX.XAPO.BufferParameters"/></strong>. <strong>ValidFrameCount</strong> indicates the number of frames that the XAPO should write to the output buffer. On output, the value of <strong><see cref = "SharpDX.XAPO.BufferParameters"/></strong>. <strong>ValidFrameCount</strong> indicates the actual number of frames written.</p> </dd></param>
/// <param name = "isEnabled"><dd> <p> TRUE to process normally; <see cref = "SharpDX.Result.False"/> to process thru. See Remarks for additional information.</p> </dd></param>
/// <remarks>
/// <p>Implementations of this function should not block, as the function is called from the realtime audio processing thread. </p><p>All code that could cause a delay, such as format validation and memory allocation, should be put in the <strong>IXAPO::LockForProcess</strong> method, which is not called from the realtime audio processing thread. </p><p>For in-place processing, the <em>pInputProcessParameters</em> parameter will not necessarily be the same as <em>pOutputProcessParameters</em>. Rather, their <em>pBuffer</em> members will point to the same memory. </p><p>Multiple input and output buffers may be used with in-place XAPOs, though the input buffer count must equal the output buffer count. For in-place processing when multiple input and output buffers are used, the XAPO may assume the number of input buffers equals the number of output buffers. </p><p>In addition to writing to the output buffer, as appropriate, an XAPO is responsible for setting the output stream's buffer flags and valid frame count. </p><p>When <em>IsEnabled</em> is <see cref = "SharpDX.Result.False"/>, the XAPO should not apply its normal processing to the given input/output buffers during. It should instead pass data from input to output with as little modification possible. Effects that perform format conversion should continue to do so. Effects must ensure transitions between normal and thru processing do not introduce discontinuities into the signal. </p><p>When writing a <strong>Process</strong> method, it is important to note XAudio2 audio data is interleaved, which means data from each channel is adjacent for a particular sample number. For example, if there was a 4-channel wave playing into an XAudio2 source voice, the audio data would be a sample of channel 0, a sample of channel 1, a sample of channel 2, a sample of channel 3, and then the next sample of channels 0, 1, 2, 3, and so on.
/// </p>
/// </remarks>
/// <doc-id>microsoft.directx_sdk.ixapo.ixapo.process</doc-id>
/// <unmanaged>void IXAPO::Process([In] unsigned int InputProcessParameterCount,[In, Buffer, Optional] const XAPO_PROCESS_BUFFER_PARAMETERS* pInputProcessParameters,[In] unsigned int OutputProcessParameterCount,[In, Buffer] XAPO_PROCESS_BUFFER_PARAMETERS* pOutputProcessParameters,[In] BOOL IsEnabled)</unmanaged>
/// <unmanaged-short>IXAPO::Process</unmanaged-short>
internal unsafe void Process_(System.Int32 inputProcessParameterCount, SharpDX.XAPO.BufferParameters[] inputProcessParametersRef, System.Int32 outputProcessParameterCount, SharpDX.XAPO.BufferParameters[] outputProcessParametersRef, SharpDX.Mathematics.Interop.RawBool isEnabled)
{
fixed(void *outputProcessParametersRef_ = outputProcessParametersRef)
fixed(void *inputProcessParametersRef_ = inputProcessParametersRef)
SharpDX.XAudio2.LocalInterop.CalliStdCallvoid0(this._nativePointer, inputProcessParameterCount, inputProcessParametersRef_, outputProcessParameterCount, outputProcessParametersRef_, isEnabled, (*(void ***)this._nativePointer)[10]);
}
public static unsafe int Calliint176(void *thisObject, float arg0, float arg1, void *arg2, SharpDX.Mathematics.Interop.RawBool arg3, SharpDX.Mathematics.Interop.RawBool arg4, int arg5, void *arg6, void *arg7, void *methodPtr)
{
throw new NotImplementedException();
}
// Method to marshal from native to managed struct
internal unsafe void __MarshalFrom(ref __Native @ref)
{
this.InputSignaturePointer = @ref.InputSignaturePointer;
this.IsInline = @ref.IsInline;
this.BytecodePointer = @ref.BytecodePointer;
this.BytecodeLength = @ref.BytecodeLength;
this.StreamOutputDeclaration = ( @ref.StreamOutputDeclaration == IntPtr.Zero )?null:Marshal.PtrToStringAnsi(@ref.StreamOutputDeclaration);
this.InputParameterCount = @ref.InputParameterCount;
this.OutputParameterCount = @ref.OutputParameterCount;
}
public static unsafe int Calliint182(void *thisObject, void *arg0, int arg1, SharpDX.Mathematics.Interop.RawBool arg2, SharpDX.Mathematics.Interop.RawBool arg3, SharpDX.DirectWrite.ScriptAnalysis arg4, void *arg5, void *arg6, void *arg7, void *methodPtr)
{
throw new NotImplementedException();
}
// Method to marshal from native to managed struct
internal unsafe void __MarshalFrom(ref __Native @ref)
{
this.Height = @ref.Height;
this.Width = @ref.Width;
this.Weight = @ref.Weight;
this.MipLevels = @ref.MipLevels;
this.Italic = @ref.Italic;
this.CharacterSet = @ref.CharacterSet;
this.OutputPrecision = @ref.OutputPrecision;
this.Quality = @ref.Quality;
this.PitchAndFamily = @ref.PitchAndFamily;
fixed (char* __ptr = &@ref.FaceName) this.FaceName = SharpDX.Utilities.PtrToStringUni((IntPtr)__ptr, 32);
}
private unsafe static extern void XInputEnable_(SharpDX.Mathematics.Interop.RawBool arg0);
// Method to marshal from native to managed struct
internal unsafe void __MarshalFrom(ref __Native @ref)
{
this.IsAlphaToCoverageEnabled = @ref.IsAlphaToCoverageEnabled;
fixed (void* __to = &this.IsBlendEnabled[0]) fixed (void* __from = &@ref.IsBlendEnabled) SharpDX.Utilities.CopyMemory((IntPtr) __to, (IntPtr) __from, 8*sizeof ( SharpDX.Mathematics.Interop.RawBool));
this.SourceBlend = @ref.SourceBlend;
this.DestinationBlend = @ref.DestinationBlend;
this.BlendOperation = @ref.BlendOperation;
this.SourceAlphaBlend = @ref.SourceAlphaBlend;
this.DestinationAlphaBlend = @ref.DestinationAlphaBlend;
this.AlphaBlendOperation = @ref.AlphaBlendOperation;
fixed (void* __to = &this.RenderTargetWriteMask[0]) fixed (void* __from = &@ref.RenderTargetWriteMask) SharpDX.Utilities.CopyMemory((IntPtr) __to, (IntPtr) __from, 8*sizeof ( byte));
}
public static unsafe int CalliStdCallint0(void *thisObject, void *param0, SharpDX.Mathematics.Interop.RawBool param1, SharpDX.Mathematics.Interop.RawBool param2, void *methodPtr)
{
throw null;
}
// Method to marshal from native to managed struct
internal unsafe void __MarshalFrom(ref __Native @ref)
{
this.IsAlphaToCoverageEnabled = @ref.IsAlphaToCoverageEnabled;
this.IndependentBlendEnable = @ref.IndependentBlendEnable;
fixed (void* __to = &this.RenderTarget[0]) fixed (void* __from = &@ref.RenderTarget) SharpDX.Utilities.CopyMemory((IntPtr) __to, (IntPtr) __from, 8*sizeof ( SharpDX.Direct3D10.RenderTargetBlendDescription1));
}
public static unsafe int CalliFuncint124(void *arg0, int arg1, int arg2, int arg3, int arg4, SharpDX.Mathematics.Interop.RawBool arg5, int arg6, int arg7, int arg8, int arg9, void *arg10, void *arg11, void *funcPtr)
{
throw new NotImplementedException();
}
public static unsafe int CalliStdCallFuncint0(void *param0, void *param1, SharpDX.Mathematics.Interop.RawBool param2, void *funcPtr)
{
throw null;
}
public static unsafe int CalliFuncint172(void *arg0, SharpDX.Mathematics.Interop.RawBool arg1, void *arg2, void *arg3, void *funcPtr)
{
throw new NotImplementedException();
}
public static unsafe int Calliint141(void *thisObject, SharpDX.Mathematics.Interop.RawBool arg0, SharpDX.DirectWrite.TextRange arg1, void *methodPtr)
{
throw new NotImplementedException();
}
public static unsafe SharpDX.Mathematics.Interop.RawBool CalliStdCallSharpDXMathematicsInteropRawBool0(void *thisObject, SharpDX.Mathematics.Interop.RawBool param0, void *methodPtr)
{
throw null;
}
public static unsafe int Calliint172(void *thisObject, void *arg0, void *arg1, void *arg2, int arg3, void *arg4, void *arg5, int arg6, void *arg7, float arg8, float arg9, void *arg10, SharpDX.Mathematics.Interop.RawBool arg11, SharpDX.Mathematics.Interop.RawBool arg12, SharpDX.Mathematics.Interop.RawBool arg13, void *arg14, void *arg15, void *arg16, void *arg17, int arg18, void *arg19, void *arg20, void *methodPtr)
{
throw new NotImplementedException();
}
public static unsafe int Calliint57(void *thisObject, int arg0, SharpDX.Mathematics.Interop.RawBool arg1, void *arg2, void *methodPtr)
{
throw new NotImplementedException();
}
public static unsafe void Callivoid80(void *thisObject, void *arg0, int arg1, SharpDX.Mathematics.Interop.RawBool arg2, SharpDX.Mathematics.Interop.RawBool arg3, SharpDX.Mathematics.Interop.RawBool arg4, void *methodPtr)
{
throw new NotImplementedException();
}
