public virtual int SetTargetRect(
            ref tagRECT pRect
            )
        {
            var fp = GetFunctionPointer(5);

            if (m_SetTargetRectFunc == null)
            {
                m_SetTargetRectFunc = (SetTargetRectFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(SetTargetRectFunc));
            }

            return(m_SetTargetRectFunc(m_ptr, ref pRect));
        }
        public virtual int GetSourceRect(
            out tagRECT pRect
            )
        {
            var fp = GetFunctionPointer(7);

            if (m_GetSourceRectFunc == null)
            {
                m_GetSourceRectFunc = (GetSourceRectFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(GetSourceRectFunc));
            }

            return(m_GetSourceRectFunc(m_ptr, out pRect));
        }
Beispiel #3
0
        public virtual int ReleaseDC(
            out tagRECT pDirtyRect
            )
        {
            var fp = GetFunctionPointer(12);

            if (m_ReleaseDCFunc == null)
            {
                m_ReleaseDCFunc = (ReleaseDCFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(ReleaseDCFunc));
            }

            return(m_ReleaseDCFunc(m_ptr, out pDirtyRect));
        }
        public virtual void GetOutputBounds(
            out tagRECT outputBounds
            )
        {
            var fp = GetFunctionPointer(5);

            if (m_GetOutputBoundsFunc == null)
            {
                m_GetOutputBoundsFunc = (GetOutputBoundsFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(GetOutputBoundsFunc));
            }

            m_GetOutputBoundsFunc(m_ptr, out outputBounds);
        }
        public virtual void SetOutputBounds(
            ref tagRECT outputBounds
            )
        {
            var fp = GetFunctionPointer(4);

            if (m_SetOutputBoundsFunc == null)
            {
                m_SetOutputBoundsFunc = (SetOutputBoundsFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(SetOutputBoundsFunc));
            }

            m_SetOutputBoundsFunc(m_ptr, ref outputBounds);
        }
        public virtual int ReleaseDC(
            ref tagRECT update
            )
        {
            var fp = GetFunctionPointer(4);

            if (m_ReleaseDCFunc == null)
            {
                m_ReleaseDCFunc = (ReleaseDCFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(ReleaseDCFunc));
            }

            return(m_ReleaseDCFunc(m_ptr, ref update));
        }
        public virtual void RSSetScissorRects(
            uint NumRects,
            ref tagRECT pRects
            )
        {
            var fp = GetFunctionPointer(22);

            if (m_RSSetScissorRectsFunc == null)
            {
                m_RSSetScissorRectsFunc = (RSSetScissorRectsFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(RSSetScissorRectsFunc));
            }

            m_RSSetScissorRectsFunc(m_ptr, NumRects, ref pRects);
        }
        public virtual int CreateBoundsAdjustmentTransform(
            ref tagRECT outputRectangle,
            out ID2D1BoundsAdjustmentTransform transform
            )
        {
            var fp = GetFunctionPointer(10);

            if (m_CreateBoundsAdjustmentTransformFunc == null)
            {
                m_CreateBoundsAdjustmentTransformFunc = (CreateBoundsAdjustmentTransformFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(CreateBoundsAdjustmentTransformFunc));
            }
            transform = new ID2D1BoundsAdjustmentTransform();
            return(m_CreateBoundsAdjustmentTransformFunc(m_ptr, ref outputRectangle, out transform.PtrForNew));
        }
        public virtual int GetAlphaTextureBounds(
            DWRITE_TEXTURE_TYPE textureType,
            out tagRECT textureBounds
            )
        {
            var fp = GetFunctionPointer(3);

            if (m_GetAlphaTextureBoundsFunc == null)
            {
                m_GetAlphaTextureBoundsFunc = (GetAlphaTextureBoundsFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(GetAlphaTextureBoundsFunc));
            }

            return(m_GetAlphaTextureBoundsFunc(m_ptr, textureType, out textureBounds));
        }
        public virtual int BindDC(
            IntPtr hDC,
            ref tagRECT pSubRect
            )
        {
            var fp = GetFunctionPointer(57);

            if (m_BindDCFunc == null)
            {
                m_BindDCFunc = (BindDCFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(BindDCFunc));
            }

            return(m_BindDCFunc(m_ptr, hDC, ref pSubRect));
        }
Beispiel #11
0
        public virtual int GetFrameDirtyRects(
            uint DirtyRectsBufferSize,
            out tagRECT pDirtyRectsBuffer,
            out uint pDirtyRectsBufferSizeRequired
            )
        {
            var fp = GetFunctionPointer(9);

            if (m_GetFrameDirtyRectsFunc == null)
            {
                m_GetFrameDirtyRectsFunc = (GetFrameDirtyRectsFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(GetFrameDirtyRectsFunc));
            }

            return(m_GetFrameDirtyRectsFunc(m_ptr, DirtyRectsBufferSize, out pDirtyRectsBuffer, out pDirtyRectsBufferSizeRequired));
        }
Beispiel #12
0
        public virtual int MapOutputRectToInputRects(
            ref tagRECT outputRect,
            out tagRECT inputRects,
            uint inputRectsCount
            )
        {
            var fp = GetFunctionPointer(4);

            if (m_MapOutputRectToInputRectsFunc == null)
            {
                m_MapOutputRectToInputRectsFunc = (MapOutputRectToInputRectsFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(MapOutputRectToInputRectsFunc));
            }

            return(m_MapOutputRectToInputRectsFunc(m_ptr, ref outputRect, out inputRects, inputRectsCount));
        }
Beispiel #13
0
        public virtual int MapInvalidRect(
            uint inputIndex,
            tagRECT invalidInputRect,
            out tagRECT invalidOutputRect
            )
        {
            var fp = GetFunctionPointer(6);

            if (m_MapInvalidRectFunc == null)
            {
                m_MapInvalidRectFunc = (MapInvalidRectFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(MapInvalidRectFunc));
            }

            return(m_MapInvalidRectFunc(m_ptr, inputIndex, invalidInputRect, out invalidOutputRect));
        }
        public virtual int Draw(
            ID2D1Bitmap1 target,
            ref tagRECT drawRect,
            D2D_POINT_2U targetOrigin
            )
        {
            var fp = GetFunctionPointer(8);

            if (m_DrawFunc == null)
            {
                m_DrawFunc = (DrawFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(DrawFunc));
            }

            return(m_DrawFunc(m_ptr, target != null ? target.Ptr : IntPtr.Zero, ref drawRect, targetOrigin));
        }
        public virtual int CalculateThreadgroups(
            ref tagRECT outputRect,
            out uint dimensionX,
            out uint dimensionY,
            out uint dimensionZ
            )
        {
            var fp = GetFunctionPointer(8);

            if (m_CalculateThreadgroupsFunc == null)
            {
                m_CalculateThreadgroupsFunc = (CalculateThreadgroupsFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(CalculateThreadgroupsFunc));
            }

            return(m_CalculateThreadgroupsFunc(m_ptr, ref outputRect, out dimensionX, out dimensionY, out dimensionZ));
        }
        public virtual int CreateAlphaTexture(
            DWRITE_TEXTURE_TYPE textureType,
            ref tagRECT textureBounds,
            out byte alphaValues,
            uint bufferSize
            )
        {
            var fp = GetFunctionPointer(4);

            if (m_CreateAlphaTextureFunc == null)
            {
                m_CreateAlphaTextureFunc = (CreateAlphaTextureFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(CreateAlphaTextureFunc));
            }

            return(m_CreateAlphaTextureFunc(m_ptr, textureType, ref textureBounds, out alphaValues, bufferSize));
        }
        public virtual void ClearRenderTargetView(
            D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView,
            ref float ColorRGBA,
            uint NumRects,
            ref tagRECT pRects
            )
        {
            var fp = GetFunctionPointer(48);

            if (m_ClearRenderTargetViewFunc == null)
            {
                m_ClearRenderTargetViewFunc = (ClearRenderTargetViewFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(ClearRenderTargetViewFunc));
            }

            m_ClearRenderTargetViewFunc(m_ptr, RenderTargetView, ref ColorRGBA, NumRects, ref pRects);
        }
Beispiel #18
0
        public virtual int MapInputRectsToOutputRect(
            ref tagRECT inputRects,
            ref tagRECT inputOpaqueSubRects,
            uint inputRectCount,
            out tagRECT outputRect,
            out tagRECT outputOpaqueSubRect
            )
        {
            var fp = GetFunctionPointer(5);

            if (m_MapInputRectsToOutputRectFunc == null)
            {
                m_MapInputRectsToOutputRectFunc = (MapInputRectsToOutputRectFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(MapInputRectsToOutputRectFunc));
            }

            return(m_MapInputRectsToOutputRectFunc(m_ptr, ref inputRects, ref inputOpaqueSubRects, inputRectCount, out outputRect, out outputOpaqueSubRect));
        }
        public virtual void ClearUnorderedAccessViewFloat(
            D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap,
            D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
            ID3D12Resource pResource,
            ref float Values,
            uint NumRects,
            ref tagRECT pRects
            )
        {
            var fp = GetFunctionPointer(50);

            if (m_ClearUnorderedAccessViewFloatFunc == null)
            {
                m_ClearUnorderedAccessViewFloatFunc = (ClearUnorderedAccessViewFloatFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(ClearUnorderedAccessViewFloatFunc));
            }

            m_ClearUnorderedAccessViewFloatFunc(m_ptr, ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource != null ? pResource.Ptr : IntPtr.Zero, ref Values, NumRects, ref pRects);
        }
        public virtual void ClearDepthStencilView(
            D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView,
            D3D12_CLEAR_FLAGS ClearFlags,
            float Depth,
            byte Stencil,
            uint NumRects,
            ref tagRECT pRects
            )
        {
            var fp = GetFunctionPointer(47);

            if (m_ClearDepthStencilViewFunc == null)
            {
                m_ClearDepthStencilViewFunc = (ClearDepthStencilViewFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(ClearDepthStencilViewFunc));
            }

            m_ClearDepthStencilViewFunc(m_ptr, DepthStencilView, ClearFlags, Depth, Stencil, NumRects, ref pRects);
        }
Beispiel #21
0
        public virtual int DrawGlyphRun(
            float baselineOriginX,
            float baselineOriginY,
            DWRITE_MEASURING_MODE measuringMode,
            ref DWRITE_GLYPH_RUN glyphRun,
            IDWriteRenderingParams renderingParams,
            uint textColor,
            out tagRECT blackBoxRect
            )
        {
            var fp = GetFunctionPointer(3);

            if (m_DrawGlyphRunFunc == null)
            {
                m_DrawGlyphRunFunc = (DrawGlyphRunFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(DrawGlyphRunFunc));
            }

            return(m_DrawGlyphRunFunc(m_ptr, baselineOriginX, baselineOriginY, measuringMode, ref glyphRun, renderingParams != null ? renderingParams.Ptr : IntPtr.Zero, textColor, out blackBoxRect));
        }
Beispiel #22
0
        public virtual void ResolveSubresourceRegion(
            ID3D12Resource pDstResource,
            uint DstSubresource,
            uint DstX,
            uint DstY,
            ID3D12Resource pSrcResource,
            uint SrcSubresource,
            out tagRECT pSrcRect,
            DXGI_FORMAT Format,
            D3D12_RESOLVE_MODE ResolveMode
            )
        {
            var fp = GetFunctionPointer(64);

            if (m_ResolveSubresourceRegionFunc == null)
            {
                m_ResolveSubresourceRegionFunc = (ResolveSubresourceRegionFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(ResolveSubresourceRegionFunc));
            }

            m_ResolveSubresourceRegionFunc(m_ptr, pDstResource != null ? pDstResource.Ptr : IntPtr.Zero, DstSubresource, DstX, DstY, pSrcResource != null ? pSrcResource.Ptr : IntPtr.Zero, SrcSubresource, out pSrcRect, Format, ResolveMode);
        }