5283 lines
422 KiB
C++
5283 lines
422 KiB
C++
/*==========================================================================;
|
|
*
|
|
* Copyright (C) Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* File: d3d9.h
|
|
* Content: Xbox 360 Direct3D include file
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifndef _D3D9_H_
|
|
#define _D3D9_H_
|
|
|
|
#if defined(_XBOX)
|
|
#include "xbox.h"
|
|
#elif defined(_X86_)
|
|
#include <malloc.h>
|
|
#endif
|
|
|
|
#include <sal.h>
|
|
|
|
#pragma warning( push )
|
|
|
|
// Disable unreferenced parameter, nameless struct/union, zero-sized
|
|
// array, structure padded due to __declspec(align()) and conditional
|
|
// expression is constant warnings for this header.
|
|
|
|
#pragma warning( disable : 4100 4201 4200 4324 4127 )
|
|
|
|
#define DIRECT3D_VERSION 0x0900
|
|
#define D3D_SDK_VERSION 0
|
|
|
|
/****************************************************************************
|
|
*
|
|
* D3DCOMPILE_USEVOIDS
|
|
*
|
|
* On Xbox 360, all D3D APIs (except Create* calls and some other exceptions)
|
|
* always return S_OK. D3D parameter checking is only done (on debug builds)
|
|
* via assertions, so the API functions could really be declared 'void'
|
|
* and have no return value, resulting in better clarity and potentially
|
|
* slightly better performance. But the PC version of DirectX returns
|
|
* HRESULT values for all APIs, so for compatibility we declare them the
|
|
* same way, by default.
|
|
*
|
|
* If you prefer to have the D3D APIs declared as void when there is no
|
|
* return value other than S_OK, simply #define D3DCOMPILE_USEVOIDS before
|
|
* including d3d9.h.
|
|
*
|
|
* Note that Create* APIs do memory allocations and so can return either
|
|
* S_OK or E_OUTOFMEMORY.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef D3DCOMPILE_USEVOIDS
|
|
#define D3DVOID void
|
|
#define D3DVOIDRETURN return
|
|
#else
|
|
#define D3DVOID HRESULT
|
|
#define D3DVOIDRETURN return S_OK
|
|
#endif
|
|
|
|
#define D3DINLINE static __forceinline
|
|
#define D3DMINLINE __forceinline
|
|
|
|
#define D3DFASTCALL __fastcall
|
|
#define DECLSPEC_SELECTANY __declspec(selectany)
|
|
|
|
#if defined(_XBOX) && !defined(_NORESTRICT_) && !defined(_PREFAST_)
|
|
#define D3DRESTRICT __restrict
|
|
#else
|
|
#define D3DRESTRICT
|
|
#endif
|
|
|
|
#if defined(_XBOX)
|
|
// The Xbox 360 compiler supports the '__IsIntConst' intrinsic which
|
|
// always evaluates to a value of 1 if the argument is constant and
|
|
// 0 if it's not.
|
|
#define D3DISINTCONST(x) __IsIntConst((int) (x))
|
|
#else
|
|
// The x86 compiler doesn't support the '__IsIntConst' intrinsic so
|
|
// always assume that the argument is not constant in order to avoid
|
|
// code bloat.
|
|
#define D3DISINTCONST(x) FALSE
|
|
#endif
|
|
|
|
// The D3D PixBeginNamedEvent/PixEndNamedEvent/PixSetMarker device methods
|
|
// (which are not to be confused with the PIXBeginNamedEvent/PIXEndNamedEvent/
|
|
// PIXSetMarker APIs which do not need a D3D device) should compile to nothing
|
|
// on retail builds.
|
|
//
|
|
// In contrast to the pix.h's USE_PIX define, this functionality should be
|
|
// available on x86 builds when using debug libraries.
|
|
#if (defined(_DEBUG) || DBG || (defined(PROFILE) && !defined(FASTCAP)) || defined(PROFILE_BUILD))
|
|
#define USE_D3D_PIX_METHODS
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
#ifdef _XBOX
|
|
#include <PPCIntrinsics.h>
|
|
#endif
|
|
|
|
// Xbox 360 Direct3D internal native types.
|
|
|
|
typedef struct Direct3D Direct3D;
|
|
typedef struct D3DDevice D3DDevice;
|
|
typedef struct D3DStateBlock D3DStateBlock;
|
|
typedef struct D3DVertexDeclaration D3DVertexDeclaration;
|
|
typedef struct D3DVertexShader D3DVertexShader;
|
|
typedef struct D3DPixelShader D3DPixelShader;
|
|
typedef struct D3DResource D3DResource;
|
|
typedef struct D3DBaseTexture D3DBaseTexture;
|
|
typedef struct D3DTexture D3DTexture;
|
|
typedef struct D3DVolumeTexture D3DVolumeTexture;
|
|
typedef struct D3DCubeTexture D3DCubeTexture;
|
|
typedef struct D3DArrayTexture D3DArrayTexture;
|
|
typedef struct D3DLineTexture D3DLineTexture;
|
|
typedef struct D3DVertexBuffer D3DVertexBuffer;
|
|
typedef struct D3DIndexBuffer D3DIndexBuffer;
|
|
typedef struct D3DSurface D3DSurface;
|
|
typedef struct D3DVolume D3DVolume;
|
|
typedef struct D3DQuery D3DQuery;
|
|
typedef struct D3DPerfCounters D3DPerfCounters;
|
|
typedef struct D3DPerfCounterBatch D3DPerfCounterBatch;
|
|
typedef struct D3DConstantBuffer D3DConstantBuffer;
|
|
typedef struct D3DCommandBuffer D3DCommandBuffer;
|
|
typedef struct D3DAsyncCommandBufferCall D3DAsyncCommandBufferCall;
|
|
typedef struct D3DOcclusionQueryBatch D3DOcclusionQueryBatch;
|
|
|
|
// Compatibility typedefs.
|
|
|
|
#define IDirect3D9 Direct3D
|
|
#define IDirect3DDevice9 D3DDevice
|
|
#define IDirect3DStateBlock9 D3DStateBlock
|
|
#define IDirect3DVertexDeclaration9 D3DVertexDeclaration
|
|
#define IDirect3DVertexShader9 D3DVertexShader
|
|
#define IDirect3DPixelShader9 D3DPixelShader
|
|
#define IDirect3DResource9 D3DResource
|
|
#define IDirect3DBaseTexture9 D3DBaseTexture
|
|
#define IDirect3DTexture9 D3DTexture
|
|
#define IDirect3DVolumeTexture9 D3DVolumeTexture
|
|
#define IDirect3DCubeTexture9 D3DCubeTexture
|
|
#define IDirect3DArrayTexture9 D3DArrayTexture
|
|
#define IDirect3DLineTexture9 D3DLineTexture
|
|
#define IDirect3DVertexBuffer9 D3DVertexBuffer
|
|
#define IDirect3DIndexBuffer9 D3DIndexBuffer
|
|
#define IDirect3DSurface9 D3DSurface
|
|
#define IDirect3DVolume9 D3DVolume
|
|
#define IDirect3DQuery9 D3DQuery
|
|
#define IDirect3DPerfCounter9 D3DPerfCounters // keep both version here for backward compatibility
|
|
#define IDirect3DPerfCounters9 D3DPerfCounters
|
|
#define IDirect3DPerfCounterBatch9 D3DPerfCounterBatch
|
|
#define IDirect3DConstantBuffer9 D3DConstantBuffer
|
|
#define IDirect3DCommandBuffer9 D3DCommandBuffer
|
|
#define IDirect3DAsyncCommandBufferCall9 D3DAsyncCommandBufferCall
|
|
#define IDirect3DOcclusionQueryBatch9 D3DOcclusionQueryBatch
|
|
|
|
// Pointer typedefs.
|
|
|
|
typedef struct Direct3D *LPDIRECT3D9, *PDIRECT3D9;
|
|
typedef struct D3DDevice *LPDIRECT3DDEVICE9, *PDIRECT3DDEVICE9;
|
|
typedef struct D3DStateBlock *LPDIRECT3DSTATEBLOCK9, *PDIRECT3DSTATEBLOCK9;
|
|
typedef struct D3DVertexDeclaration *LPDIRECT3DVERTEXDECLARATION9, *PDIRECT3DVERTEXDECLARATION9;
|
|
typedef struct D3DVertexShader *LPDIRECT3DVERTEXSHADER9, *PDIRECT3DVERTEXSHADER9;
|
|
typedef struct D3DPixelShader *LPDIRECT3DPIXELSHADER9, *PDIRECT3DPIXELSHADER9;
|
|
typedef struct D3DResource *LPDIRECT3DRESOURCE9, *PDIRECT3DRESOURCE9;
|
|
typedef struct D3DBaseTexture *LPDIRECT3DBASETEXTURE9, *PDIRECT3DBASETEXTURE9;
|
|
typedef struct D3DTexture *LPDIRECT3DTEXTURE9, *PDIRECT3DTEXTURE9;
|
|
typedef struct D3DVolumeTexture *LPDIRECT3DVOLUMETEXTURE9, *PDIRECT3DVOLUMETEXTURE9;
|
|
typedef struct D3DCubeTexture *LPDIRECT3DCUBETEXTURE9, *PDIRECT3DCUBETEXTURE9;
|
|
typedef struct D3DArrayTexture *LPDIRECT3DARRAYTEXTURE9, *PDIRECT3DARRAYTEXTURE9;
|
|
typedef struct D3DLineTexture *LPDIRECT3DLINETEXTURE9, *PDIRECT3DLINETEXTURE9;
|
|
typedef struct D3DVertexBuffer *LPDIRECT3DVERTEXBUFFER9, *PDIRECT3DVERTEXBUFFER9;
|
|
typedef struct D3DIndexBuffer *LPDIRECT3DINDEXBUFFER9, *PDIRECT3DINDEXBUFFER9;
|
|
typedef struct D3DSurface *LPDIRECT3DSURFACE9, *PDIRECT3DSURFACE9;
|
|
typedef struct D3DVolume *LPDIRECT3DVOLUME9, *PDIRECT3DVOLUME9;
|
|
typedef struct D3DQuery *LPDIRECT3DQUERY9, *PDIRECT3DQUERY9;
|
|
typedef struct D3DPerfCounters *LPDIRECT3DPERFCOUNTERS9, *PDIRECT3DPERFCOUNTERS9;
|
|
typedef struct D3DPerfCounterBatch *LPDIRECT3DPERFCOUNTERBATCH9, *PDIRECT3DPERFCOUNTERBATCH9;
|
|
typedef struct D3DConstantBuffer *LPDIRECT3DCONSTANTBUFFER9, *PDIRECT3DCONSTANTBUFFER9;
|
|
typedef struct D3DCommandBuffer *LPDIRECT3DCOMMANDBUFFER9, *PDIRECT3DCOMMANDBUFFER9;
|
|
typedef struct D3DAsyncCommandBufferCall *LPDIRECT3DASYNCCOMMANDBUFFERCALL9, *PDIRECT3DASYNCCOMMANDBUFFERCALL9;
|
|
typedef struct D3DOcclusionQueryBatch *LPDIRECT3DOCCLUSIONQUERYBATCH9, *PDIRECT3DOCCLUSIONQUERYBATCH9;
|
|
|
|
typedef struct _D3DSURFACES {
|
|
D3DSurface* pDepthStencilSurface;
|
|
D3DSurface* pRenderTarget[4];
|
|
} D3DSURFACES;
|
|
|
|
// IDirect3DSwapChain9 is not supported on Xbox 360
|
|
|
|
#include "d3d9types.h"
|
|
#include "d3d9caps.h"
|
|
#include "d3d9xps.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
*
|
|
* D3DVECTOR4 member accessors. When _VECTOR4_STRICT_MEMBER_ACCESS_ is
|
|
* defined, individual vector components are not accessible as simple fields.
|
|
*
|
|
****************************************************************************/
|
|
|
|
D3DINLINE float D3DVECTOR4_GetX (__in D3DVECTOR4 *pVector)
|
|
{
|
|
return *(float*)pVector;
|
|
}
|
|
|
|
D3DINLINE float D3DVECTOR4_GetY (__in D3DVECTOR4 *pVector)
|
|
{
|
|
return *((float*)pVector+1);
|
|
}
|
|
|
|
D3DINLINE float D3DVECTOR4_GetZ (__in D3DVECTOR4 *pVector)
|
|
{
|
|
return *((float*)pVector+2);
|
|
}
|
|
|
|
D3DINLINE float D3DVECTOR4_GetW (__in D3DVECTOR4 *pVector)
|
|
{
|
|
return *((float*)pVector+3);
|
|
}
|
|
|
|
D3DINLINE void D3DVECTOR4_SetX (__out D3DVECTOR4 *pVector, float Value)
|
|
{
|
|
*(float*)pVector = Value;
|
|
}
|
|
|
|
D3DINLINE void D3DVECTOR4_SetY (__out D3DVECTOR4 *pVector, float Value)
|
|
{
|
|
*((float*)pVector+1) = Value;
|
|
}
|
|
|
|
D3DINLINE void D3DVECTOR4_SetZ (__out D3DVECTOR4 *pVector, float Value)
|
|
{
|
|
*((float*)pVector+2) = Value;
|
|
}
|
|
|
|
D3DINLINE void D3DVECTOR4_SetW (__out D3DVECTOR4 *pVector, float Value)
|
|
{
|
|
*((float*)pVector+3) = Value;
|
|
}
|
|
|
|
/****************************************************************************/
|
|
|
|
D3DINLINE __out Direct3D* WINAPI Direct3DCreate9(UINT SDKVersion) { return (Direct3D*) 1; }
|
|
|
|
void WINAPI Direct3DReclaimGrowableMemory(__in_bcount(Size) void* pStart, DWORD Size);
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Parameter for Direct3D Enum and GetCaps9 functions to get the info for
|
|
* the current mode only.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#define D3DCURRENT_DISPLAY_MODE 0x00EFFFFFL
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Flags for Direct3D::CreateDevice's BehaviorFlags
|
|
*
|
|
****************************************************************************/
|
|
|
|
#define D3DCREATE_PUREDEVICE 0x00000000L // Ignored on Xbox 360
|
|
#define D3DCREATE_FPU_PRESERVE 0x00000000L // Ignored on Xbox 360
|
|
#define D3DCREATE_HARDWARE_VERTEXPROCESSING 0x00000000L // Ignored on Xbox 360
|
|
#define D3DCREATE_BUFFER_2_FRAMES 0x00000001L // Xbox 360 extension
|
|
#define D3DCREATE_CLIPPER_MODE_1 0x00000002L // Xbox 360 extension
|
|
#define D3DCREATE_ASYNCHRONOUS_SWAPS 0x00000004L // Xbox 360 extension
|
|
#define D3DCREATE_NO_SHADER_PATCHING 0x00000008L // Xbox 360 extension
|
|
#define D3DCREATE_CREATE_THREAD_ON_0 0x01000000L // Xbox 360 extension
|
|
#define D3DCREATE_CREATE_THREAD_ON_1 0x02000000L // Xbox 360 extension
|
|
#define D3DCREATE_CREATE_THREAD_ON_2 0x04000000L // Xbox 360 extension
|
|
#define D3DCREATE_CREATE_THREAD_ON_3 0x08000000L // Xbox 360 extension
|
|
#define D3DCREATE_CREATE_THREAD_ON_4 0x10000000L // Xbox 360 extension
|
|
#define D3DCREATE_CREATE_THREAD_ON_5 0x20000000L // Xbox 360 extension
|
|
#define D3DCREATE_CREATE_NO_THREADS 0x00000100L // Xbox 360 extension
|
|
|
|
// The following flags are not supported on Xbox 360:
|
|
//
|
|
// D3DCREATE_MULTITHREADED
|
|
// D3DCREATE_SOFTWARE_VERTEXPROCESSING
|
|
// D3DCREATE_MIXED_VERTEXPROCESSING
|
|
// D3DCREATE_DISABLE_DRIVER_MANAGEMENT
|
|
// D3DCREATE_ADAPTERGROUP_DEVICE
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Parameter for Direct3D::CreateDevice's Adapter
|
|
*
|
|
****************************************************************************/
|
|
|
|
#define D3DADAPTER_DEFAULT 0
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Flags for Direct3D::EnumAdapters
|
|
*
|
|
****************************************************************************/
|
|
|
|
#define D3DENUM_NO_WHQL_LEVEL 0x00000002L
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Maximum number of back-buffers supported in DX9
|
|
*
|
|
****************************************************************************/
|
|
|
|
#define D3DPRESENT_BACK_BUFFERS_MAX 2L
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Flags for IDirect3DDevice9::SetGammaRamp
|
|
*
|
|
****************************************************************************/
|
|
|
|
#define D3DSGR_NO_CALIBRATION 0x00000000L
|
|
#define D3DSGR_IMMEDIATE 0x00000002L
|
|
|
|
/*
|
|
* DirectDraw error codes
|
|
*/
|
|
|
|
#define _FACD3D 0x876
|
|
#define MAKE_D3DHRESULT( code ) MAKE_HRESULT( 1, _FACD3D, code )
|
|
#define MAKE_D3DSTATUS( code ) MAKE_HRESULT( 0, _FACD3D, code )
|
|
|
|
/*
|
|
* Direct3D Errors
|
|
*/
|
|
|
|
#define D3D_OK S_OK
|
|
|
|
#define D3DERR_WRONGTEXTUREFORMAT MAKE_D3DHRESULT(2072)
|
|
#define D3DERR_UNSUPPORTEDCOLOROPERATION MAKE_D3DHRESULT(2073)
|
|
#define D3DERR_UNSUPPORTEDCOLORARG MAKE_D3DHRESULT(2074)
|
|
#define D3DERR_UNSUPPORTEDALPHAOPERATION MAKE_D3DHRESULT(2075)
|
|
#define D3DERR_UNSUPPORTEDALPHAARG MAKE_D3DHRESULT(2076)
|
|
#define D3DERR_TOOMANYOPERATIONS MAKE_D3DHRESULT(2077)
|
|
#define D3DERR_CONFLICTINGTEXTUREFILTER MAKE_D3DHRESULT(2078)
|
|
#define D3DERR_UNSUPPORTEDFACTORVALUE MAKE_D3DHRESULT(2079)
|
|
#define D3DERR_CONFLICTINGRENDERSTATE MAKE_D3DHRESULT(2081)
|
|
#define D3DERR_UNSUPPORTEDTEXTUREFILTER MAKE_D3DHRESULT(2082)
|
|
#define D3DERR_DRIVERINTERNALERROR MAKE_D3DHRESULT(2087)
|
|
|
|
#define D3DERR_NOTFOUND MAKE_D3DHRESULT(2150)
|
|
#define D3DERR_MOREDATA MAKE_D3DHRESULT(2151)
|
|
#define D3DERR_DEVICELOST MAKE_D3DHRESULT(2152)
|
|
#define D3DERR_DEVICENOTRESET MAKE_D3DHRESULT(2153)
|
|
#define D3DERR_NOTAVAILABLE MAKE_D3DHRESULT(2154)
|
|
#define D3DERR_OUTOFVIDEOMEMORY MAKE_D3DHRESULT(380)
|
|
#define D3DERR_INVALIDDEVICE MAKE_D3DHRESULT(2155)
|
|
#define D3DERR_INVALIDCALL MAKE_D3DHRESULT(2156)
|
|
#define D3DOK_NOAUTOGEN MAKE_D3DSTATUS(2159)
|
|
|
|
/****************************************************************************
|
|
*
|
|
* __declspec(selectany) has the lovely attribute that it allows the linker
|
|
* to remove duplicate instantiations of global declarations, and to remove
|
|
* the instantiation entirely if unreferenced.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#define D3DCONST extern CONST DECLSPEC_SELECTANY
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Private internal data - Please don't access these directly, as they're
|
|
* subject to change.
|
|
*
|
|
****************************************************************************/
|
|
|
|
D3DCONST UINT D3DPRIMITIVEVERTEXCOUNT[][2] =
|
|
{
|
|
{0, 0}, // Illegal = 0
|
|
{1, 0}, // D3DPT_POINTLIST = 1,
|
|
{2, 0}, // D3DPT_LINELIST = 2,
|
|
{1, 1}, // D3DPT_LINESTRIP = 3,
|
|
{3, 0}, // D3DPT_TRIANGLELIST = 4,
|
|
{1, 2}, // D3DPT_TRIANGLEFAN = 5,
|
|
{1, 2}, // D3DPT_TRIANGLESTRIP = 6,
|
|
{0, 0}, // Illegal = 7
|
|
{3, 0}, // D3DPT_RECTLIST = 8
|
|
{0, 0}, // Illegal = 9
|
|
{0, 0}, // Illegal = 10
|
|
{0, 0}, // Illegal = 11
|
|
{0, 0}, // Illegal = 12
|
|
{4, 0}, // D3DPT_QUADLIST = 13,
|
|
};
|
|
|
|
// Macro for converting from primitive count to number of vertices. When
|
|
// 'PrimitiveType' is specified as a constant, the table lookups are done
|
|
// at compile time.
|
|
//
|
|
#define D3DVERTEXCOUNT(PrimitiveType, PrimitiveCount) \
|
|
((PrimitiveCount) * D3DPRIMITIVEVERTEXCOUNT[PrimitiveType][0] \
|
|
+ D3DPRIMITIVEVERTEXCOUNT[PrimitiveType][1])
|
|
|
|
// Macro for converting from vertex count to number of primitives. When
|
|
// 'PrimitiveType' is specified as a constant, the table lookups are done
|
|
// at compile time.
|
|
//
|
|
#define D3DPRIMCOUNT(PrimitiveType, VertexCount) \
|
|
(((VertexCount) - D3DPRIMITIVEVERTEXCOUNT[PrimitiveType][1]) \
|
|
/ D3DPRIMITIVEVERTEXCOUNT[PrimitiveType][0])
|
|
|
|
// The equivalent table for tessellated primitives
|
|
D3DCONST UINT D3DTESSPRIMITIVEVERTEXCOUNT[][2] =
|
|
{
|
|
{0, 0}, // Illegal = 0
|
|
{0, 0}, // Illegal = 1,
|
|
{2, 0}, // D3DTPT_LINELIST = 2,
|
|
{1, 1}, // D3DTPT_LINESTRIP = 3,
|
|
{3, 0}, // D3DTPT_TRIANGLELIST = 4,
|
|
{1, 2}, // D3DTPT_TRIANGLEFAN = 5,
|
|
{1, 2}, // D3DTPT_TRIANGLESTRIP = 6,
|
|
{0, 0}, // Illegal = 7
|
|
{0, 0}, // Illegal = 8
|
|
{0, 0}, // Illegal = 9
|
|
{0, 0}, // Illegal = 10
|
|
{0, 0}, // Illegal = 11
|
|
{0, 0}, // Illegal = 12
|
|
{4, 0}, // D3DTPT_QUADLIST = 13,
|
|
{0, 0}, // Illegal = 14
|
|
{0, 0}, // Illegal = 15
|
|
{1, 0}, // D3DTPT_LINEPATCH = 16,
|
|
{1, 0}, // D3DTPT_TRIPATCH = 17,
|
|
{1, 0}, // D3DTPT_RECTPATCH = 18,
|
|
};
|
|
|
|
// Macro for converting from primitive count to number of vertices. When
|
|
// 'PrimitiveType' is specified as a constant, the table lookups are done
|
|
// at compile time.
|
|
//
|
|
#define D3DTESSVERTEXCOUNT(PrimitiveType, PrimitiveCount) \
|
|
((PrimitiveCount) * D3DTESSPRIMITIVEVERTEXCOUNT[PrimitiveType][0] + \
|
|
+ D3DTESSPRIMITIVEVERTEXCOUNT[PrimitiveType][1])
|
|
|
|
// Macro for converting from vertex count to number of primitives. When
|
|
// 'PrimitiveType' is specified as a constant, the table lookups are done
|
|
// at compile time.
|
|
//
|
|
#define D3DTESSPRIMCOUNT(PrimitiveType, VertexCount) \
|
|
(((VertexCount) - D3DTESSPRIMITIVEVERTEXCOUNT[PrimitiveType][1]) \
|
|
/ D3DTESSPRIMITIVEVERTEXCOUNT[PrimitiveType][0])
|
|
|
|
// 'Extern' declaration that is both C and C++ friendly.
|
|
//
|
|
#ifdef __cplusplus
|
|
#define D3DEXTERN extern "C"
|
|
#else
|
|
#define D3DEXTERN extern
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Definitions for Win64 compatibility
|
|
*
|
|
****************************************************************************/
|
|
|
|
#if defined(_PREFAST_)
|
|
|
|
#define D3DASSERT(cond, msg) __assume(cond)
|
|
|
|
#elif defined(_DEBUG)
|
|
|
|
VOID D3DRIP(__in_z CONST CHAR* Format, ...);
|
|
|
|
#define D3DASSERT(cond, msg) { if (!(cond)) D3DRIP("Assertion failure: %s\n%s", #cond, (msg)); }
|
|
|
|
#else
|
|
|
|
#define D3DASSERT(cond, msg) __noop()
|
|
|
|
#endif
|
|
|
|
|
|
#if defined(_XBOX)
|
|
|
|
D3DINLINE BOOL D3DInitializeHeap() { return TRUE; }
|
|
|
|
#define D3D__AllocAttributes ( \
|
|
MAKE_XALLOC_ATTRIBUTES(0, 0, 0, 0, \
|
|
eXALLOCAllocatorId_D3DAlloc, \
|
|
XALLOC_ALIGNMENT_16, \
|
|
XALLOC_MEMPROTECT_READWRITE, \
|
|
0, XALLOC_MEMTYPE_HEAP))
|
|
|
|
D3DINLINE void* D3DAlloc (DWORD size) { return XMemAlloc(size, D3D__AllocAttributes); }
|
|
D3DINLINE void D3DFree (void* ptr) { XMemFree(ptr, D3D__AllocAttributes); }
|
|
D3DINLINE DWORD D3DMemSize(__in void* ptr) { return XMemSize(ptr, D3D__AllocAttributes); }
|
|
|
|
D3DINLINE void* D3DPhysicalAlloc(DWORD size, DWORD protect) { return XPhysicalAlloc(size, MAXULONG_PTR, 4096, protect); }
|
|
D3DINLINE void D3DPhysicalFree (void* ptr) { XPhysicalFree(ptr); }
|
|
|
|
D3DINLINE DWORD D3DPtrToDWORD(void const* ptr) { return (DWORD) (UINT_PTR) ptr; }
|
|
D3DINLINE void* D3DDWORDToPtr(DWORD dw) { return (void*) (UINT_PTR) dw; }
|
|
|
|
#elif defined(_X86_)
|
|
|
|
D3DINLINE BOOL D3DInitializeHeap() { return TRUE; }
|
|
|
|
D3DINLINE void* D3DAlloc (DWORD size) { return _aligned_malloc( size, 16 ); }
|
|
D3DINLINE void D3DFree (void* ptr) { _aligned_free(ptr); }
|
|
DWORD D3DMemSize(__in void* ptr);
|
|
|
|
D3DINLINE void* D3DPhysicalAlloc(DWORD size, DWORD protect) { return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE); }
|
|
D3DINLINE void D3DPhysicalFree (void* ptr) { VirtualFree(ptr, 0, MEM_RELEASE); }
|
|
|
|
D3DINLINE DWORD D3DPtrToDWORD(void const* ptr) { return (DWORD) (UINT_PTR) ptr; }
|
|
D3DINLINE void* D3DDWORDToPtr(DWORD dw) { return (void*) (UINT_PTR) dw; }
|
|
|
|
#else // defined(_AMD64_)
|
|
|
|
D3DEXTERN BOOL D3DInitializeHeap();
|
|
|
|
D3DEXTERN void* D3D__Heap32Base;
|
|
D3DEXTERN DWORD D3D__Heap32Top;
|
|
|
|
D3DEXTERN void* D3DAlloc (DWORD size);
|
|
D3DEXTERN void D3DFree (void* ptr);
|
|
D3DEXTERN DWORD D3DMemSize(__in void* ptr);
|
|
|
|
D3DEXTERN void* D3DPhysicalAlloc(DWORD size, DWORD protect);
|
|
D3DEXTERN void D3DPhysicalFree (void* ptr);
|
|
|
|
D3DINLINE
|
|
DWORD D3DPtrToDWORD(void const* ptr)
|
|
{
|
|
if (ptr == NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
D3DASSERT(D3D__Heap32Base != NULL,
|
|
"D3DPtrToDWORD was called, but D3D's 32-bit heap is not yet initialized.\n"
|
|
"You should call D3DInitializeHeap first.");
|
|
|
|
D3DASSERT((BYTE*)ptr >= (BYTE*)D3D__Heap32Base && (BYTE*)ptr <= (BYTE*)D3D__Heap32Base + D3D__Heap32Top,
|
|
"D3DPtrToDWORD was called with a pointer that wasn't allocated\n"
|
|
"with D3DAlloc or D3DPhysicalAlloc.");
|
|
|
|
return (DWORD)((BYTE*)ptr - (BYTE*)D3D__Heap32Base);
|
|
}
|
|
|
|
D3DINLINE
|
|
void* D3DDWORDToPtr(DWORD dw)
|
|
{
|
|
if (dw == 0)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
D3DASSERT(dw <= D3D__Heap32Top,
|
|
"D3DDWORDToPtr was called with a value that's outside of the heap.\n"
|
|
"Either this value wasn't obtained with D3DPtrToDWORD,\n"
|
|
"or the data it referenced has been freed.");
|
|
|
|
return (BYTE*)D3D__Heap32Base + dw;
|
|
}
|
|
|
|
#endif // _AMD64_
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Definitions for public fields in Xbox 360's D3D objects
|
|
*
|
|
****************************************************************************/
|
|
|
|
// Structure for maintaining D3D's shadow of all GPU constants.
|
|
//
|
|
typedef struct _D3DConstants
|
|
{
|
|
union {
|
|
GPUFETCH_CONSTANT Fetch[GPU_FETCH_CONSTANTS];
|
|
struct {
|
|
GPUTEXTURE_FETCH_CONSTANT TextureFetch[GPU_D3D_TEXTURE_FETCH_CONSTANT_COUNT];
|
|
GPUVERTEX_FETCH_CONSTANT VertexFetch[3*GPU_D3D_VERTEX_FETCH_CONSTANT_COUNT];
|
|
};
|
|
};
|
|
union {
|
|
D3DVECTOR4 Alu[GPU_ALU_CONSTANTS];
|
|
struct {
|
|
D3DVECTOR4 VertexShaderF[GPU_D3D_VERTEX_CONSTANTF_COUNT];
|
|
D3DVECTOR4 PixelShaderF[GPU_D3D_PIXEL_CONSTANTF_COUNT];
|
|
};
|
|
};
|
|
union {
|
|
DWORD Flow[GPU_FLOW_CONSTANTS];
|
|
struct {
|
|
DWORD VertexShaderB[GPU_D3D_VERTEX_CONSTANTB_COUNT/32];
|
|
DWORD PixelShaderB[GPU_D3D_PIXEL_CONSTANTB_COUNT/32];
|
|
DWORD VertexShaderI[GPU_D3D_VERTEX_CONSTANTI_COUNT];
|
|
DWORD PixelShaderI[GPU_D3D_PIXEL_CONSTANTI_COUNT];
|
|
};
|
|
};
|
|
} D3DConstants;
|
|
|
|
// Function prototypes
|
|
//
|
|
typedef void (WINAPI *D3DSETRENDERSTATECALL)(__in D3DDevice* pDevice, DWORD Value);
|
|
typedef void (WINAPI *D3DSETSAMPLERSTATECALL)(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
|
|
typedef DWORD (WINAPI *D3DGETRENDERSTATECALL)(__in D3DDevice* pDevice);
|
|
typedef DWORD (WINAPI *D3DGETSAMPLERSTATECALL)(__in D3DDevice* pDevice, DWORD Sampler);
|
|
|
|
void WINAPI D3DTagCollection_SetVertexShaderConstantFTag_ParameterCheck(DWORD StartConstant, DWORD ConstantCount);
|
|
void WINAPI D3DTagCollection_SetPixelShaderConstantFTag_ParameterCheck(DWORD StartConstant, DWORD ConstantCount);
|
|
|
|
// Helpers for decoding ownership of GPU registers
|
|
//
|
|
D3DINLINE DWORD D3DTag_Index(D3DTAG Tag)
|
|
{
|
|
return D3DTAG_INDEX(Tag);
|
|
}
|
|
D3DINLINE DWORD D3DTag_Count(D3DTAG Tag)
|
|
{
|
|
return D3DTAG_COUNT(Tag);
|
|
}
|
|
D3DINLINE UINT64 D3DTag_SubsetMask(D3DTAG Tag, DWORD StartIndex, DWORD EndIndex)
|
|
{
|
|
return D3DTAG_MASKENCODE(D3DTAG_START(Tag) + StartIndex, D3DTAG_START(Tag) + EndIndex);
|
|
}
|
|
D3DINLINE UINT64 D3DTag_Mask(D3DTAG Tag)
|
|
{
|
|
return D3DTag_SubsetMask(Tag, 0, D3DTAG_COUNT(Tag) - 1);
|
|
}
|
|
D3DINLINE UINT64 D3DTag_ShaderConstantMask(DWORD StartConstant, DWORD ConstantCount)
|
|
{
|
|
// D3DTAG_PIXELSHADERCONSTANTS vs D3DTAG_VERTEXSHADERCONSTANTS doesn't matter here
|
|
return D3DTag_SubsetMask(D3DTAG_VERTEXSHADERCONSTANTS, StartConstant / 4, (StartConstant + ConstantCount - 1) / 4);
|
|
}
|
|
D3DINLINE UINT64 D3DTag_SamplerMask(DWORD Sampler)
|
|
{
|
|
return D3DTag_SubsetMask(D3DTAG_TEXTUREFETCHCONSTANTS, Sampler, Sampler);
|
|
}
|
|
|
|
// Structure representing every context register on the GPU
|
|
typedef struct _D3DTAGCOLLECTION
|
|
{
|
|
UINT64 m_Mask[5];
|
|
|
|
} D3DTAGCOLLECTION;
|
|
|
|
D3DINLINE void D3DTagCollection_Set(__in D3DTAGCOLLECTION* pCollection, DWORD Index, UINT64 Mask)
|
|
{
|
|
pCollection->m_Mask[Index] |= Mask;
|
|
}
|
|
D3DINLINE void D3DTagCollection_SetAll(__in D3DTAGCOLLECTION* pCollection)
|
|
{
|
|
pCollection->m_Mask[0] = ~((UINT64) 0);
|
|
pCollection->m_Mask[1] = ~((UINT64) 0);
|
|
pCollection->m_Mask[2] = ~((UINT64) 0);
|
|
pCollection->m_Mask[3] = ~((UINT64) 0);
|
|
pCollection->m_Mask[4] = ~((UINT64) 0);
|
|
}
|
|
D3DINLINE void D3DTagCollection_Clear(__in D3DTAGCOLLECTION* pCollection, DWORD Index, UINT64 Mask)
|
|
{
|
|
pCollection->m_Mask[Index] &= ~Mask;
|
|
}
|
|
D3DINLINE BOOL D3DTagCollection_TestAny(__in D3DTAGCOLLECTION* pCollection, DWORD Index, UINT64 Mask)
|
|
{
|
|
return (pCollection->m_Mask[Index] & Mask) != 0;
|
|
}
|
|
D3DINLINE BOOL D3DTagCollection_TestAll(__in D3DTAGCOLLECTION* pCollection, DWORD Index, UINT64 Mask)
|
|
{
|
|
return (pCollection->m_Mask[Index] & Mask) == Mask;
|
|
}
|
|
|
|
D3DINLINE void D3DTagCollection_SetTag(__in D3DTAGCOLLECTION* pCollection, D3DTAG Tag)
|
|
{
|
|
D3DTagCollection_Set(pCollection, D3DTag_Index(Tag), D3DTag_Mask(Tag));
|
|
}
|
|
D3DINLINE void D3DTagCollection_SetVertexShaderConstantFTag(__in D3DTAGCOLLECTION* pCollection, DWORD StartConstant, DWORD ConstantCount)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DTagCollection_SetVertexShaderConstantFTag_ParameterCheck(StartConstant, ConstantCount);
|
|
#endif
|
|
|
|
D3DTagCollection_Set(pCollection, D3DTag_Index(D3DTAG_VERTEXSHADERCONSTANTS), D3DTag_ShaderConstantMask(StartConstant, ConstantCount));
|
|
}
|
|
D3DINLINE void D3DTagCollection_SetPixelShaderConstantFTag(__in D3DTAGCOLLECTION* pCollection, DWORD StartConstant, DWORD ConstantCount)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DTagCollection_SetPixelShaderConstantFTag_ParameterCheck(StartConstant, ConstantCount);
|
|
#endif
|
|
|
|
D3DTagCollection_Set(pCollection, D3DTag_Index(D3DTAG_PIXELSHADERCONSTANTS), D3DTag_ShaderConstantMask(StartConstant, ConstantCount));
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Publicly accessible globals - Feel free to modify the values.
|
|
*
|
|
****************************************************************************/
|
|
|
|
// Set D3D__NullHardware to TRUE to enable infinitely fast hardware (so fast
|
|
// you can't even see the results). This is useful for determining how CPU-
|
|
// bound your program is.
|
|
//
|
|
D3DEXTERN BOOL D3D__NullHardware;
|
|
|
|
// Set D3D__SingleStepper to TRUE on debug versions of D3D to cause D3D to
|
|
// do an implicit BlockUntilIdle after every D3D draw call. This is useful
|
|
// for tracking weird hardware crashes and hangs down to the problem draw call.
|
|
//
|
|
D3DEXTERN BOOL D3D__SingleStepper;
|
|
|
|
// Set D3D__BreakOnDeprecation to TRUE on debug versions of D3D to cause D3D
|
|
// to break into the debugger when warning about deprecated D3D functionality.
|
|
//
|
|
D3DEXTERN BOOL D3D__BreakOnDeprecation;
|
|
|
|
#if defined(_DEBUG)
|
|
|
|
// Set D3D__DisableConstantOverwriteCheck to disable the shader constant
|
|
// overwrite checks. These checks are only performed for debug builds.) This is
|
|
// useful when D3D is warning you about constants being overwritten, but you
|
|
// know that it's OK. (Perhaps you know that for some draw calls the shader
|
|
// doesn't actually use the constants that were overwritten.)
|
|
//
|
|
D3DEXTERN BOOL D3D__DisableConstantOverwriteCheck;
|
|
|
|
// Set D3D__DisableAllChecks to disable all errors, warnings, notifications
|
|
// and assertions thrown in D3D APIs. This is only performed for debug builds.
|
|
// This is useful when D3D is complaining about something, but you know that
|
|
// it's OK in your particular case. You should reset this immediately to FALSE
|
|
// after calling the APIs that would complain.
|
|
//
|
|
// Note that updates to this global affect all threads, and are not thread-safe
|
|
// unless you make it thread-safe.
|
|
//
|
|
// Note that, if D3D would normally crash or misbehave in any way if you
|
|
// continue execution after a failure breakpoint, it will now crash or
|
|
// misbehave identically. There is no alternative failure recovery.
|
|
//
|
|
// If you encounter the need to use this toggle, please report the
|
|
// circumstances to gameds@microsoft.com.
|
|
//
|
|
D3DEXTERN BOOL D3D__DisableAllChecks;
|
|
|
|
// Set D3D__DisableBreakOnError to disable breaking into the debugger in D3D
|
|
// APIs. This is only performed for debug builds. This is useful when D3D is
|
|
// breaking into the debugger, but you know that it's OK in your particular
|
|
// case. D3D will still report the error as a warning. You should reset this
|
|
// immediately to FALSE after calling the APIs that would break.
|
|
//
|
|
// Note that updates to this global affect all threads, and are not thread-safe
|
|
// unless you make it thread-safe.
|
|
//
|
|
// Note that, if D3D would normally crash or misbehave in any way if you
|
|
// continue execution after a failure breakpoint, it will now crash or
|
|
// misbehave identically. There is no alternative failure recovery.
|
|
//
|
|
// If you encounter the need to use this toggle, please report the
|
|
// circumstances to gameds@microsoft.com.
|
|
//
|
|
D3DEXTERN BOOL D3D__DisableBreakOnError;
|
|
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Miscellaneous public defines
|
|
*
|
|
****************************************************************************/
|
|
|
|
// Types of our various callback functions.
|
|
//
|
|
typedef void (WINAPI *D3DCALLBACK)(DWORD Context);
|
|
typedef void (WINAPI *D3DVBLANKCALLBACK)(__in D3DVBLANKDATA *pData);
|
|
typedef void (WINAPI *D3DSWAPCALLBACK)(__in D3DSWAPDATA *pData);
|
|
typedef void (WINAPI *D3DHANGCALLBACK)(__in_z CONST char* pDescription);
|
|
typedef void (WINAPI *D3DBLOCKCALLBACK)(DWORD Flags, D3DBLOCKTYPE BlockType, float ClockTime, DWORD ThreadTime);
|
|
typedef void* (WINAPI *D3DALLOCATECALLBACK)(DWORD Context, DWORD Flags, __inout DWORD* pSize, DWORD Alignment);
|
|
typedef void (WINAPI *D3DFREECALLBACK)(DWORD Context);
|
|
typedef void (WINAPI *D3DQUERYCALLBACK)(DWORD Context, __out DWORD* pUsed, __out DWORD* pRemaining);
|
|
typedef void (WINAPI *D3DTEXTURETRACKERERRORCALLBACK)(BOOL bIsGuiInitiatedCapture, __in_z CONST char* pDescription);
|
|
|
|
/*
|
|
* D3DQuery, IDirect3DQuery9 interface
|
|
*
|
|
* There are no public fields
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
|
|
struct D3DQuery
|
|
{
|
|
ULONG WINAPI AddRef();
|
|
ULONG WINAPI Release();
|
|
|
|
D3DVOID WINAPI GetDevice(__deref_out D3DDevice **ppDevice);
|
|
D3DQUERYTYPE WINAPI GetType();
|
|
DWORD WINAPI GetDataSize();
|
|
D3DVOID WINAPI Issue(DWORD IssueFlags);
|
|
HRESULT WINAPI GetData(__out_bcount(Size) void* pData, DWORD Size, DWORD GetDataFlags);
|
|
};
|
|
|
|
#endif __cplusplus
|
|
|
|
|
|
/*
|
|
* D3DPerfCounters, IDirect3DPerfCounters9 interface
|
|
*
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
|
|
struct D3DPerfCounters
|
|
{
|
|
ULONG WINAPI AddRef();
|
|
ULONG WINAPI Release();
|
|
|
|
D3DVOID WINAPI GetDevice(__deref_out D3DDevice **ppDevice);
|
|
BOOL WINAPI IsBusy();
|
|
void WINAPI BlockUntilNotBusy();
|
|
UINT WINAPI GetNumPasses();
|
|
HRESULT WINAPI GetValues(__out D3DPERFCOUNTER_VALUES* pValues, UINT InstanceIndex, __out_opt DWORD* pMask);
|
|
};
|
|
|
|
#endif __cplusplus
|
|
|
|
|
|
|
|
/*
|
|
* D3DStateBlock, IDirect3DStateBlock9 interface
|
|
*
|
|
* There are no public fields
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
|
|
struct D3DStateBlock
|
|
{
|
|
ULONG WINAPI AddRef();
|
|
ULONG WINAPI Release();
|
|
|
|
D3DVOID WINAPI GetDevice(__deref_out D3DDevice **ppDevice);
|
|
D3DVOID WINAPI Capture();
|
|
D3DVOID WINAPI Apply();
|
|
};
|
|
|
|
#endif __cplusplus
|
|
|
|
/*
|
|
* D3DResource, IDirect3DResource9 interface
|
|
*
|
|
* The root structure of all D3D 'resources' such as textures and vertex buffers.
|
|
*/
|
|
|
|
#define D3DCOMMON_TYPE_MASK 0x0000000F
|
|
#define D3DCOMMON_TYPE_SHIFT 0
|
|
#define D3DCOMMON_TYPE_VERTEXBUFFER (D3DRTYPE_VERTEXBUFFER << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_INDEXBUFFER (D3DRTYPE_INDEXBUFFER << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_TEXTURE (D3DRTYPE_TEXTURE << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_SURFACE (D3DRTYPE_SURFACE << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_VERTEXDECLARATION (D3DRTYPE_VERTEXDECLARATION << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_VERTEXSHADER (D3DRTYPE_VERTEXSHADER << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_PIXELSHADER (D3DRTYPE_PIXELSHADER << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_CONSTANTBUFFER (D3DRTYPE_CONSTANTBUFFER << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_COMMANDBUFFER (D3DRTYPE_COMMANDBUFFER << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_ASYNCCOMMANDBUFFERCALL (D3DRTYPE_ASYNCCOMMANDBUFFERCALL << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_PERFCOUNTERBATCH (D3DRTYPE_PERFCOUNTERBATCH << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_OCCLUSIONQUERYBATCH (D3DRTYPE_OCCLUSIONQUERYBATCH << D3DCOMMON_TYPE_SHIFT)
|
|
#define D3DCOMMON_TYPE_RESERVED (0xf << D3DCOMMON_TYPE_SHIFT)
|
|
|
|
#define D3DCOMMON_LOCKID_MASK 0x000000F0
|
|
#define D3DCOMMON_LOCKID_SHIFT 4
|
|
|
|
#define D3DCOMMON_LOCKCOUNT_MASK 0x00000F00
|
|
#define D3DCOMMON_LOCKCOUNT_SHIFT 8
|
|
|
|
#if defined(_DEBUG)
|
|
|
|
// The following is used by D3D only on debug builds and is used to keep
|
|
// count of internal reference counts for debug purposes
|
|
//
|
|
#define D3DCOMMON_DEBUG_INTREFCOUNT_MASK 0x0001F000
|
|
#define D3DCOMMON_DEBUG_INTREFCOUNT_SHIFT 12
|
|
|
|
// The following is used by D3D only on debug builds and is set when a
|
|
// resource is referenced by a command buffer
|
|
//
|
|
#define D3DCOMMON_DEBUG_COMMMANDBUFFER_USED 0x00020000
|
|
|
|
// The following is used by D3D only on debug builds and is set when a
|
|
// resource is involved in one or more pending asynchronous operations.
|
|
//
|
|
#define D3DCOMMON_DEBUG_ASYNCLOCK 0x00040000
|
|
|
|
// The following is used by D3D only on debug builds to prevent
|
|
// multiple simultaneous asynchronous locks, which are not allowed.
|
|
//
|
|
#define D3DCOMMON_DEBUG_ASYNCLOCK_LOCKED 0x00080000
|
|
|
|
#endif
|
|
|
|
// Internal flag to indicate that this resource was created by Direct3D.
|
|
//
|
|
#define D3DCOMMON_D3DCREATED 0x00100000
|
|
|
|
// When accessing this resource via the CPU, the CPU uses a cached memory
|
|
// view. D3D ensures coherency with the GPU by flushing the modified
|
|
// range at Unlock time.
|
|
//
|
|
#define D3DCOMMON_CPU_CACHED_MEMORY 0x00200000
|
|
|
|
// Update the fence for this resource when a command buffer using this resource
|
|
// is run.
|
|
//
|
|
#define D3DCOMMON_RUNCOMMANDBUFFER_TIMESTAMP 0x00400000
|
|
|
|
#if defined(_DEBUG)
|
|
|
|
// The following is used by D3D only on debug builds and is a count
|
|
// of pending asynchronous locks, for debug purposes
|
|
//
|
|
#define D3DCOMMON_DEBUG_ASYNCLOCK_PENDING_MASK 0x1F800000
|
|
#define D3DCOMMON_DEBUG_ASYNCLOCK_PENDING_INC 0x00800000
|
|
|
|
#endif
|
|
|
|
// The rest of the bits may be used by derived classes.
|
|
//
|
|
#define D3DCOMMON_UNUSED_MASK 0xE0000000
|
|
#define D3DCOMMON_UNUSED_SHIFT 29
|
|
|
|
// Initialize the 'BaseFlush' and 'MipFlush' fields to this value.
|
|
//
|
|
#define D3DFLUSH_INITIAL_VALUE 0xffff0000
|
|
|
|
struct D3DResource
|
|
{
|
|
|
|
#ifdef __cplusplus
|
|
|
|
ULONG WINAPI AddRef();
|
|
ULONG WINAPI Release();
|
|
|
|
D3DVOID WINAPI GetDevice(__deref_out D3DDevice **ppDevice);
|
|
D3DRESOURCETYPE WINAPI GetType();
|
|
BOOL WINAPI IsBusy();
|
|
BOOL WINAPI IsSet(__in D3DDevice *pDevice);
|
|
void WINAPI BlockUntilNotBusy();
|
|
void WINAPI SetIdentifier(DWORD Identifier);
|
|
DWORD WINAPI GetIdentifier();
|
|
|
|
// The following methods are not supported on Xbox 360:
|
|
//
|
|
// SetPrivateData
|
|
// GetPrivateData
|
|
// FreePrivateData
|
|
// SetPriority
|
|
// GetPriority
|
|
// PreLoad
|
|
|
|
#endif __cplusplus
|
|
|
|
// All resources need these fields. Inherit them in C++.
|
|
|
|
DWORD Common; // Flags common to all resources
|
|
DWORD ReferenceCount; // External reference count
|
|
DWORD Fence; // This is the fence number of the last ring buffer
|
|
// reference to this resource. (This field was
|
|
// known as 'Lock' on the original Xbox.)
|
|
// Initialize it to zero.
|
|
DWORD ReadFence; // This is used to determine when it's safe for the
|
|
// CPU to read a resource that was written to
|
|
// by the GPU. Initialize it to zero.
|
|
DWORD Identifier; // Game-supplied data that identifies the resource
|
|
DWORD BaseFlush; // Encodes the memory range to be flushed by D3D
|
|
// via 'dcbf' at 'Unlock' time. Initialize it
|
|
// to D3DFLUSH_INITIAL_VALUE.
|
|
};
|
|
|
|
/*
|
|
* D3DBaseTexture interface
|
|
*
|
|
* The root structure of all D3D textures. Inherits all of the methods
|
|
* from D3DResource.
|
|
*/
|
|
|
|
#define D3DTEXTURE_ALIGNMENT 4096
|
|
|
|
struct D3DBaseTexture
|
|
#ifdef __cplusplus
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
|
|
#ifdef __cplusplus
|
|
DWORD WINAPI GetLevelCount();
|
|
D3DVOID WINAPI GetTailDesc(__out D3DMIPTAIL_DESC *pDesc);
|
|
D3DVOID WINAPI LockTail(UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockTail(D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI UnlockTail(UINT ArrayIndex);
|
|
#endif
|
|
|
|
// The following methods are not supported on Xbox 360:
|
|
//
|
|
// SetLOD
|
|
// GetLOD
|
|
// SetAutoGenFilterType
|
|
// GetAutoGenFilterType
|
|
// GenerateMipSubLevels
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
|
|
DWORD MipFlush; // Encodes the mip's memory range to be flushed by D3D
|
|
// via 'dcbf' at 'Unlock' time. Initialize it
|
|
// to D3DFLUSH_INITIAL_VALUE.
|
|
GPUTEXTURE_FETCH_CONSTANT Format;
|
|
// The hardware's description of the texture
|
|
};
|
|
|
|
|
|
/*
|
|
* D3DTexture, IDirect3DTexture9 interface
|
|
*
|
|
* A normal texture. Inherits from D3DBaseTexture
|
|
*/
|
|
|
|
struct D3DTexture
|
|
#ifdef __cplusplus
|
|
: public D3DBaseTexture
|
|
#endif
|
|
{
|
|
|
|
#ifdef __cplusplus
|
|
D3DVOID WINAPI GetLevelDesc(UINT Level, __out D3DSURFACE_DESC *pDesc);
|
|
HRESULT WINAPI GetSurfaceLevel(UINT Level, __deref_out D3DSurface **ppSurfaceLevel);
|
|
D3DVOID WINAPI LockRect(UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockRect(D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
D3DVOID WINAPI UnlockRect(UINT Level);
|
|
D3DVOID WINAPI LockTail(__out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockTail(D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI UnlockTail();
|
|
|
|
// The following methods are not supported on Xbox 360:
|
|
//
|
|
// AddDirtyRect
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DBaseTexture
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
DWORD MipFlush;
|
|
GPUTEXTURE_FETCH_CONSTANT Format;
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
/*
|
|
* D3DVolumeTexture, IDirect3DVolumeTexture9 interface
|
|
*
|
|
* A volume texture. Inherits from D3DBaseTexture
|
|
*/
|
|
|
|
struct D3DVolumeTexture
|
|
#ifdef __cplusplus
|
|
: public D3DBaseTexture
|
|
#endif
|
|
{
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DVOID WINAPI GetLevelDesc(UINT Level, __out D3DVOLUME_DESC *pDesc);
|
|
HRESULT WINAPI GetVolumeLevel(UINT Level, __deref_out D3DVolume **ppVolumeLevel);
|
|
D3DVOID WINAPI LockBox(UINT Level, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockBox(D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags);
|
|
D3DVOID WINAPI UnlockBox(UINT Level);
|
|
D3DVOID WINAPI LockTail(__out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockTail(D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI UnlockTail();
|
|
|
|
// The following methods are not supported on Xbox 360:
|
|
//
|
|
// AddDirtyBox
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DBaseTexture
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
DWORD MipFlush;
|
|
GPUTEXTURE_FETCH_CONSTANT Format;
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
/*
|
|
* D3DCubeTexture, IDirect3DCubeTexture9 interface
|
|
*
|
|
* A cube texture. Inherits from D3DBaseTexture
|
|
*/
|
|
|
|
struct D3DCubeTexture
|
|
#ifdef __cplusplus
|
|
: public D3DBaseTexture
|
|
#endif
|
|
{
|
|
|
|
#ifdef __cplusplus
|
|
D3DVOID WINAPI GetLevelDesc(UINT Level, __out D3DSURFACE_DESC *pDesc);
|
|
HRESULT WINAPI GetCubeMapSurface(D3DCUBEMAP_FACES FaceType, UINT Level, __deref_out D3DSurface **ppCubeMapSurface);
|
|
D3DVOID WINAPI LockRect(D3DCUBEMAP_FACES FaceType, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockRect(D3DASYNCBLOCK AsyncBlock, D3DCUBEMAP_FACES FaceType, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
D3DVOID WINAPI UnlockRect(D3DCUBEMAP_FACES FaceType, UINT Level);
|
|
D3DVOID WINAPI LockTail(D3DCUBEMAP_FACES FaceType, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockTail(D3DASYNCBLOCK AsyncBlock, D3DCUBEMAP_FACES FaceType, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI UnlockTail(D3DCUBEMAP_FACES FaceType);
|
|
|
|
// The following methods are not supported on Xbox 360:
|
|
//
|
|
// AddDirtyRect
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DBaseTexture
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
DWORD MipFlush;
|
|
GPUTEXTURE_FETCH_CONSTANT Format;
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
/*
|
|
* D3DArrayTexture, IDirect3DArrayTexture9 interface
|
|
*
|
|
* An array texture. Inherits from D3DBaseTexture
|
|
*/
|
|
|
|
struct D3DArrayTexture
|
|
#ifdef __cplusplus
|
|
: public D3DBaseTexture
|
|
#endif
|
|
{
|
|
|
|
#ifdef __cplusplus
|
|
DWORD WINAPI GetArraySize();
|
|
D3DVOID WINAPI GetLevelDesc(UINT Level, __out D3DSURFACE_DESC *pDesc);
|
|
HRESULT WINAPI GetArraySurface(UINT ArrayIndex, UINT Level, __deref_out D3DSurface **ppArraySurface);
|
|
D3DVOID WINAPI LockRect(UINT ArrayIndex, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockRect(D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
D3DVOID WINAPI UnlockRect(UINT ArrayIndex, UINT Level);
|
|
D3DVOID WINAPI LockTail(UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockTail(D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI UnlockTail(UINT ArrayIndex);
|
|
|
|
// The following methods are not supported on Xbox 360:
|
|
//
|
|
// AddDirtyRect
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DBaseTexture
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
DWORD MipFlush;
|
|
GPUTEXTURE_FETCH_CONSTANT Format;
|
|
#endif
|
|
|
|
};
|
|
|
|
/*
|
|
* D3DLineTexture, IDirect3DLineTexture9 interface
|
|
*
|
|
* A 1D texture. Inherits from D3DBaseTexture
|
|
*/
|
|
|
|
struct D3DLineTexture
|
|
#ifdef __cplusplus
|
|
: public D3DBaseTexture
|
|
#endif
|
|
{
|
|
|
|
#ifdef __cplusplus
|
|
D3DVOID WINAPI GetLevelDesc(UINT Level, __out D3DSURFACE_DESC *pDesc);
|
|
HRESULT WINAPI GetSurfaceLevel(UINT Level, __deref_out D3DSurface **ppSurfaceLevel);
|
|
D3DVOID WINAPI LockRect(UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockRect(D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
D3DVOID WINAPI UnlockRect(UINT Level);
|
|
D3DVOID WINAPI LockTail(__out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockTail(D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
D3DVOID WINAPI UnlockTail();
|
|
|
|
// The following methods are not supported on Xbox 360:
|
|
//
|
|
// AddDirtyRect
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DBaseTexture
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
DWORD MipFlush;
|
|
GPUTEXTURE_FETCH_CONSTANT Format;
|
|
#endif
|
|
|
|
};
|
|
|
|
/*
|
|
* D3DVertexBuffer, IDirect3DVertexBuffer9 interface
|
|
*
|
|
* A vertex buffer.
|
|
*
|
|
* The data for the vertex buffer must be aligned on a D3DVERTEXBUFFER_ALIGNMENT
|
|
* byte multiple.
|
|
*/
|
|
|
|
#define D3DVERTEXBUFFER_ALIGNMENT 4
|
|
|
|
struct D3DVertexBuffer
|
|
#ifdef __cplusplus
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
D3DVOID WINAPI Lock(UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLock(D3DASYNCBLOCK AsyncBlock, UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags);
|
|
D3DVOID WINAPI Unlock();
|
|
D3DVOID WINAPI GetDesc(__out D3DVERTEXBUFFER_DESC *pDesc);
|
|
|
|
#endif __cplusplus
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
|
|
GPUVERTEX_FETCH_CONSTANT Format;
|
|
};
|
|
|
|
|
|
/*
|
|
* D3DIndexBuffer, IDirect3DIndexBuffer9 interface
|
|
*
|
|
* An index buffer.
|
|
*
|
|
* The data for the vertex buffer must be aligned on a D3DINDEXBUFFER_ALIGNMENT
|
|
* byte multiple.
|
|
*/
|
|
|
|
#define D3DINDEXBUFFER_ALIGNMENT 4
|
|
|
|
// If set in the 'Common' field, this bit indicates that the indices are
|
|
// 32-bit values instead of 16-bit:
|
|
//
|
|
#define D3DINDEXBUFFER_INDEX32 0x80000000
|
|
|
|
// This bitfield in 'Common' indicates the GPUENDIAN endianness to be used when
|
|
// the GPU reads the index buffer:
|
|
//
|
|
#define D3DINDEXBUFFER_ENDIAN_MASK 0X60000000
|
|
#define D3DINDEXBUFFER_ENDIAN_SHIFT 29
|
|
|
|
struct D3DIndexBuffer
|
|
#ifdef __cplusplus
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
D3DVOID WINAPI Lock(UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLock(D3DASYNCBLOCK AsyncBlock, UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags);
|
|
D3DVOID WINAPI Unlock();
|
|
D3DVOID WINAPI GetDesc(__out D3DINDEXBUFFER_DESC *pDesc);
|
|
|
|
#endif __cplusplus
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
|
|
DWORD Address;
|
|
DWORD Size;
|
|
};
|
|
|
|
|
|
/*
|
|
* D3DSurface, IDirect3DSurface9 interface
|
|
*
|
|
*/
|
|
|
|
#define D3DSURFACE_ALIGNMENT 4096
|
|
|
|
// This internal flag indicates whether D3D allocated the EDRAM memory,
|
|
// or whether it was specified by the game via D3DSURFACE_PARAMETERS.
|
|
|
|
#define D3DCOMMON_SURFACE_D3D_EDRAM_ALLOCATED 0x80000000
|
|
|
|
// This internal flag indicates that this resource is a surface that
|
|
// was derived from a texture (via something like GetSurfaceLevel).
|
|
// As such, it doesn't own the memory to which it's pointing, and
|
|
// it can't be set as a render target.
|
|
//
|
|
#define D3DCOMMON_SURFACE_FROM_TEXTURE 0x40000000
|
|
|
|
struct D3DSurface
|
|
#if defined(__cplusplus)
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
HRESULT WINAPI GetContainer(REFIID UnusedRiid, __deref_out void **ppContainer);
|
|
D3DVOID WINAPI GetDesc(__out D3DSURFACE_DESC *pDesc);
|
|
|
|
D3DVOID WINAPI LockRect(__out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockRect(D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
D3DVOID WINAPI UnlockRect();
|
|
|
|
// The following methods are not supported on Xbox 360:
|
|
//
|
|
// GetDC
|
|
// ReleaseDC
|
|
|
|
#endif __cplusplus
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
// The following fields are valid only if D3DCOMMON_SURFACEFROMTEXTURE
|
|
// is not set:
|
|
|
|
GPU_SURFACEINFO SurfaceInfo;
|
|
union {
|
|
GPU_DEPTHINFO DepthInfo;
|
|
GPU_COLORINFO ColorInfo;
|
|
};
|
|
GPU_HICONTROL HiControl;
|
|
struct {
|
|
DWORD Width : 14;
|
|
DWORD Height : 15;
|
|
DWORD : 3;
|
|
};
|
|
D3DFORMAT Format;
|
|
DWORD Size;
|
|
};
|
|
struct {
|
|
|
|
// The following fields are valid only if D3DCOMMON_SURFACEFROMTEXTURE
|
|
// is set:
|
|
|
|
D3DBaseTexture *Parent;
|
|
struct {
|
|
DWORD MipLevel : 4;
|
|
DWORD ArrayIndex : 6;
|
|
DWORD : 22;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
/*
|
|
* D3DVolume, IDirect3DVolume9 interface
|
|
*/
|
|
|
|
#define D3DVOLUME_ALIGNMENT 4096
|
|
|
|
struct D3DVolume
|
|
#if defined(__cplusplus)
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
HRESULT WINAPI GetContainer(REFIID UnusedRiid, __deref_out void **ppContainer);
|
|
D3DVOID WINAPI GetDesc(__out D3DVOLUME_DESC *pDesc);
|
|
D3DVOID WINAPI LockBox(__out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLockBox(D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags);
|
|
D3DVOID WINAPI UnlockBox();
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
|
|
D3DBaseTexture *Parent;
|
|
struct {
|
|
DWORD MipLevel : 4;
|
|
DWORD ArrayIndex : 6;
|
|
DWORD : 22;
|
|
};
|
|
};
|
|
|
|
/*
|
|
* D3DVertexDeclaration, IDirect3DVertexDeclaration9 interface
|
|
*
|
|
* D3D keeps private internal fields in addition to the public fields for
|
|
* this structure.
|
|
*/
|
|
|
|
struct D3DVertexDeclaration
|
|
#ifdef __cplusplus
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
D3DVOID WINAPI GetDeclaration(__out_ecount_part(*pNumElements, *pNumElements) D3DVERTEXELEMENT9 *pDecl, __inout UINT *pNumElements);
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
};
|
|
|
|
/*
|
|
* D3DVertexShader, IDirect3DVertexShader9 interface
|
|
*
|
|
* D3D keeps private internal fields in addition to the public fields for
|
|
* this structure.
|
|
*/
|
|
|
|
#define VERTEXSHADER_ALIGNMENT 32
|
|
|
|
struct D3DVertexShader
|
|
#ifdef __cplusplus
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
D3DVOID WINAPI GetFunction(__out_bcount_opt(*pSizeOfData) void *pData, __inout UINT* pSizeOfData);
|
|
D3DVOID WINAPI Bind(DWORD Flags, __in D3DVertexDeclaration* pVertexDeclaration, __in CONST DWORD* pStreamStrides, __in_opt D3DPixelShader* pPixelShader);
|
|
BOOL WINAPI IsBound();
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
};
|
|
|
|
/*
|
|
* D3DPixelShader, IDirect3DPixelShader9 interface
|
|
*
|
|
* D3D keeps private internal fields in addition to the public fields for
|
|
* this structure.
|
|
*/
|
|
|
|
#define PIXELSHADER_ALIGNMENT 32
|
|
|
|
struct D3DPixelShader
|
|
#ifdef __cplusplus
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
D3DVOID WINAPI GetFunction(__out_bcount_opt(*pSizeOfData) void *pData, __inout UINT* pSizeOfData);
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
};
|
|
|
|
/*
|
|
* D3DConstantBuffer, IDirect3DConstantBuffer9 interface
|
|
*/
|
|
|
|
#define D3DCONSTANTBUFFER_ALIGNMENT 16
|
|
|
|
struct D3DConstantBuffer
|
|
#if defined(__cplusplus)
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
D3DVOID WINAPI Lock(__deref_out D3DVECTOR4** ppData, DWORD Flags);
|
|
D3DVOID WINAPI AsyncLock(D3DASYNCBLOCK AsyncBlock, __deref_out D3DVECTOR4** ppData, DWORD Flags);
|
|
D3DVOID WINAPI Unlock();
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
|
|
DWORD Address;
|
|
DWORD Size;
|
|
};
|
|
|
|
/*
|
|
* D3DCommandBuffer, IDirect3DCommandBuffer9 interface
|
|
*/
|
|
|
|
#define D3DCOMMANDBUFFER_ALIGNMENT 32
|
|
|
|
struct D3DCommandBuffer
|
|
#if defined(__cplusplus)
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
D3DVOID WINAPI GetResources(DWORD Flags, __out_ecount_opt(*pBufferSize) D3DResource** ppResourceList, __inout DWORD* pBufferSize);
|
|
HRESULT WINAPI CreateClone(DWORD Flags, __deref_out D3DCommandBuffer** ppCommandBuffer);
|
|
D3DVOID WINAPI GetClone(DWORD Flags, __out_bcount_opt(*pHeaderSize) D3DCommandBuffer* pHeaderPart, __inout DWORD* pHeaderSize, __out_bcount_opt(*pPhysicalSize) void* pPhysicalPart, __inout DWORD* pPhysicalSize);
|
|
D3DVOID WINAPI BeginFixupCreation();
|
|
HRESULT WINAPI EndFixupCreation();
|
|
HRESULT WINAPI Deconstruct(DWORD Flags, __out_bcount_opt(*pHeaderSize) D3DCommandBuffer* pHeaderPart, __inout DWORD* pHeaderSize, __out_bcount_opt(*pPhysicalSize) void* pPhysicalPart, __inout DWORD* pPhysicalSize, __out_bcount_opt(*pInitializationSize) void* pInitializationPart, __inout DWORD* pInitializationSize);
|
|
D3DVOID WINAPI BeginReconstruction(DWORD Flags, __in void* pPhysicalPart, __in void* pInitializationPart);
|
|
D3DVOID WINAPI EndReconstruction();
|
|
D3DVOID WINAPI BeginDynamicFixups();
|
|
D3DVOID WINAPI EndDynamicFixups();
|
|
DWORD WINAPI CreateSurfacesFixup(DWORD Flags, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI CreateClipRectFixup(DWORD Flags, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI CreateViewportFixup(DWORD Flags, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI CreateVertexShaderConstantFFixup(DWORD Flags, DWORD StartRegister, DWORD Vector4fCount, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI CreatePixelShaderConstantFFixup(DWORD Flags, DWORD StartRegister, DWORD Vector4fCount, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI CreateVertexShaderFixup(DWORD Flags, __in D3DVertexShader* pVertexShader, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI CreatePixelShaderFixup(DWORD Flags, __in D3DPixelShader* pPixelShader, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI CreateTextureFixup(DWORD Flags, __in D3DBaseTexture* pTexture, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI CreateIndexBufferFixup(DWORD Flags, __in D3DIndexBuffer* pIndexBuffer, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI CreateVertexBufferFixup(DWORD Flags, __in D3DVertexBuffer* pVertexBuffer, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI CreateConstantBufferFixup(DWORD Flags, __in D3DConstantBuffer* pConstantBuffer, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI CreateCommandBufferFixup(DWORD Flags, __in D3DCommandBuffer* pCommandBuffer, DWORD StartMarker, DWORD StopMarker);
|
|
D3DVOID WINAPI SetSurfaces(DWORD FixupHandle, __in CONST D3DSURFACES* pSurfaces);
|
|
D3DVOID WINAPI SetClipRect(DWORD FixupHandle, __in CONST RECT* pRect);
|
|
D3DVOID WINAPI SetViewport(DWORD FixupHandle, __in CONST D3DVIEWPORT9* pViewport);
|
|
D3DVOID WINAPI SetVertexShaderConstantF(DWORD FixupHandle, __in CONST float* pConstantData);
|
|
D3DVOID WINAPI SetPixelShaderConstantF(DWORD FixupHandle, __in CONST float* pConstantData);
|
|
D3DVOID WINAPI SetVertexShader(DWORD FixupHandle, __in D3DVertexShader* pVertexShader);
|
|
D3DVOID WINAPI SetPixelShader(DWORD FixupHandle, __in D3DPixelShader* pPixelShader);
|
|
D3DVOID WINAPI SetTexture(DWORD FixupHandle, __in D3DBaseTexture* pTexture);
|
|
D3DVOID WINAPI SetIndexBuffer(DWORD FixupHandle, __in D3DIndexBuffer* pIndexBuffer);
|
|
D3DVOID WINAPI SetVertexBuffer(DWORD FixupHandle, __in D3DVertexBuffer* pVertexBuffer);
|
|
D3DVOID WINAPI SetConstantBuffer(DWORD FixupHandle, __in D3DConstantBuffer* pConstantBuffer);
|
|
D3DVOID WINAPI SetCommandBuffer(DWORD FixupHandle, __in D3DCommandBuffer* pCommandBuffer);
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
|
|
// Flags indicating which registers are inherited from the GPU's current
|
|
// state when the command buffer is run. Inheritance is used to pass
|
|
// run-time parameters such as shader constants to the command buffer.
|
|
//
|
|
D3DTAGCOLLECTION m_Inherited;
|
|
|
|
// Flags indicating which registers are to be persisted after the
|
|
// command buffer is run.
|
|
//
|
|
D3DTAGCOLLECTION m_Persisted;
|
|
};
|
|
|
|
/*
|
|
* D3DAsyncCommandBufferCall, IDirect3DAsyncCommandBufferCall9 interface
|
|
*/
|
|
|
|
struct D3DAsyncCommandBufferCall
|
|
#if defined(__cplusplus)
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
D3DVOID WINAPI FixupAndSignal(__in_opt D3DCommandBuffer* pUserCommandBuffer, DWORD PredicationSelect, DWORD Flags);
|
|
D3DVOID WINAPI FixupAndSignalEx(__in_ecount_opt(CommandBufferCount) D3DCommandBuffer** ppUserCommandBuffers, __in_ecount_opt(CommandBufferCount) DWORD* pPredicationSelects, DWORD CommandBufferCount, DWORD Flags);
|
|
HRESULT WINAPI Reset(__in_opt D3DTAGCOLLECTION* pInheritTags, __in_opt D3DTAGCOLLECTION* pPersistTags, DWORD NumSegments, DWORD Flags);
|
|
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
|
|
// Flags indicating which registers are inherited from the GPU's current
|
|
// state when the async command buffer call is run. Inheritance is used to pass
|
|
// run-time parameters such as shader constants to the command buffer.
|
|
//
|
|
D3DTAGCOLLECTION m_Inherited;
|
|
|
|
// Flags indicating which registers are to be persisted after the
|
|
// async command buffer call is run.
|
|
//
|
|
D3DTAGCOLLECTION m_Persisted;
|
|
};
|
|
|
|
/*
|
|
* D3DPerfCounterBatch, IDirect3DPerfCounterBatch9 interface
|
|
*
|
|
*/
|
|
|
|
struct D3DPerfCounterBatch
|
|
#ifdef __cplusplus
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
void WINAPI Reset();
|
|
UINT WINAPI Issue(DWORD PerfCounterIndex, DWORD Flags);
|
|
UINT WINAPI GetNumSlotsUsed();
|
|
D3DVOID WINAPI Lock(__deref_out void **ppData);
|
|
D3DVOID WINAPI Unlock();
|
|
UINT WINAPI GetValue32(DWORD Slot);
|
|
UINT64 WINAPI GetValue64(DWORD Slot);
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
|
|
// D3DPERFCOUNTERBATCH_* Flags indicating the creation type
|
|
|
|
DWORD m_Flags;
|
|
|
|
// Number of slots, each slot correspond to one Issue()
|
|
|
|
DWORD m_NumSlots;
|
|
|
|
// Number of passes in each slot
|
|
|
|
DWORD m_NumPasses;
|
|
|
|
// Size in bytes of each slot
|
|
|
|
DWORD m_SlotSize;
|
|
|
|
// Slots used
|
|
|
|
UINT m_SlotsUsed;
|
|
|
|
// Base address of physical memory for GPU write back, write-combined
|
|
|
|
BYTE* m_pBase;
|
|
|
|
// Cached read only address
|
|
|
|
BYTE* m_pCachedReadOnlyBase;
|
|
};
|
|
|
|
/*
|
|
* D3DOcclusionQueryBatch, IDirect3DOcclusionQueryBatch9 interface
|
|
*
|
|
*/
|
|
|
|
struct D3DOcclusionQueryBatch
|
|
#ifdef __cplusplus
|
|
: public D3DResource
|
|
#endif
|
|
{
|
|
#ifdef __cplusplus
|
|
void WINAPI Reset();
|
|
UINT WINAPI Issue();
|
|
UINT WINAPI GetNumSlotsUsed();
|
|
D3DVOID WINAPI Lock(__deref_out void **ppData);
|
|
D3DVOID WINAPI Unlock();
|
|
void WINAPI GetOcclusionStats(DWORD Slot, __out D3DOCCLUSIONSTATS* pOcclusionStats);
|
|
UINT WINAPI GetPixelCount(DWORD Slot);
|
|
#endif
|
|
|
|
#ifndef __cplusplus
|
|
// Manually inherit these from D3DResource
|
|
DWORD Common;
|
|
DWORD ReferenceCount;
|
|
DWORD Fence;
|
|
DWORD ReadFence;
|
|
DWORD Identifier;
|
|
DWORD BaseFlush;
|
|
#endif
|
|
|
|
// Number of slots, each slot correspond to one Issue()
|
|
|
|
DWORD m_NumSlots;
|
|
|
|
// Number of tiles in each slot
|
|
|
|
DWORD m_NumTiles;
|
|
|
|
// Size in bytes of each slot
|
|
|
|
DWORD m_SlotSize;
|
|
|
|
// Slots used
|
|
|
|
UINT m_SlotsUsed;
|
|
|
|
// Base address of physical memory for GPU write back, write-combined
|
|
|
|
BYTE* m_pBase;
|
|
|
|
// Cached read only address
|
|
|
|
BYTE* m_pCachedReadOnlyBase;
|
|
};
|
|
|
|
/*
|
|
* Direct3D, IDirect3D9 interface
|
|
*
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
|
|
struct Direct3D
|
|
{
|
|
|
|
static ULONG WINAPI AddRef();
|
|
static ULONG WINAPI Release();
|
|
|
|
static UINT WINAPI GetAdapterCount();
|
|
static HRESULT WINAPI GetAdapterIdentifier(UINT Adapter, DWORD Flags, __out D3DADAPTER_IDENTIFIER9 *pIdentifier);
|
|
static HRESULT WINAPI CheckDeviceType(UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL Windowed);
|
|
static HRESULT WINAPI CheckDeviceFormat(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat);
|
|
static HRESULT WINAPI CheckDeviceMultiSampleType(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType, __out_opt DWORD* pQualityLevels);
|
|
static HRESULT WINAPI CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat);
|
|
static HRESULT WINAPI CheckDeviceFormatConversion(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat);
|
|
static HRESULT WINAPI GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,__out D3DCAPS9 *pCaps);
|
|
static HRESULT WINAPI CreateDevice(UINT Adapter, D3DDEVTYPE DeviceType, __in_opt void *hUnusedFocusWindow, DWORD BehaviorFlags, __in_opt D3DPRESENT_PARAMETERS *pPresentationParameters, __deref_out D3DDevice **ppReturnedDeviceInterface);
|
|
|
|
// The following APIs are all Xbox 360 extensions:
|
|
|
|
static void WINAPI QueryGpuVersion(__out D3DGPUVERSION* pGpuVersion);
|
|
|
|
// The following methods are not supported on Xbox 360:
|
|
//
|
|
// RegisterSoftwareDevice
|
|
// GetAdapterMonitor
|
|
};
|
|
|
|
#endif __cplusplus
|
|
|
|
/*
|
|
* D3DDevice, IDirect3DDevice9 interface
|
|
*/
|
|
|
|
struct D3DDevice
|
|
{
|
|
#ifdef __cplusplus
|
|
|
|
// Standard D3D APIs:
|
|
|
|
ULONG WINAPI AddRef();
|
|
ULONG WINAPI Release();
|
|
D3DVOID WINAPI GetDirect3D(__deref_out Direct3D **ppD3D9);
|
|
D3DVOID WINAPI GetDeviceCaps(__out D3DCAPS9 *pCaps);
|
|
D3DVOID WINAPI GetDisplayMode(UINT UnusedSwapChain, __out D3DDISPLAYMODE *pMode);
|
|
D3DVOID WINAPI GetCreationParameters(__out D3DDEVICE_CREATION_PARAMETERS *pParameters);
|
|
HRESULT WINAPI Reset(__in D3DPRESENT_PARAMETERS *pPresentationParameters);
|
|
D3DVOID WINAPI Present(__in_opt CONST RECT *pUnusedSourceRect, __in_opt CONST RECT *pUnusedDestRect, __in_opt void *hUnusedDestWindowOverride, __in_opt void *pUnusedDirtyRegion);
|
|
D3DVOID WINAPI GetRasterStatus(UINT iUnusedSwapChain, __out D3DRASTER_STATUS *pRasterStatus);
|
|
void WINAPI SetGammaRamp(UINT iUnusedSwapChain, DWORD UnusedFlags, __in CONST D3DGAMMARAMP *pRamp);
|
|
void WINAPI GetGammaRamp(UINT iUnusedSwapChain, __out D3DGAMMARAMP *pRamp);
|
|
void WINAPI SetPWLGamma(DWORD Flags, __in CONST D3DPWLGAMMA *pRamp);
|
|
void WINAPI GetPWLGamma(__out D3DPWLGAMMA *pRamp);
|
|
HRESULT WINAPI CreateTexture(UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DTexture **ppTexture, __in_opt HANDLE* pUnusedSharedHandle);
|
|
HRESULT WINAPI CreateVolumeTexture(UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DVolumeTexture **ppVolumeTexture, __in_opt HANDLE* pUnusedSharedHandle);
|
|
HRESULT WINAPI CreateCubeTexture(UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DCubeTexture **ppCubeTexture, __in_opt HANDLE* pUnusedSharedHandle);
|
|
HRESULT WINAPI CreateArrayTexture(UINT Width, UINT Height, UINT ArraySize, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DArrayTexture **ppArrayTexture, __in_opt HANDLE* pUnusedSharedHandle);
|
|
HRESULT WINAPI CreateLineTexture(UINT Width, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DLineTexture **ppTexture, __in_opt HANDLE* pUnusedSharedHandle);
|
|
HRESULT WINAPI CreateVertexBuffer(UINT Length, DWORD Usage, DWORD UnusedFVF, D3DPOOL UnusedPool, __deref_out D3DVertexBuffer **ppVertexBuffer, __in_opt HANDLE* pUnusedSharedHandle);
|
|
HRESULT WINAPI CreateIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DIndexBuffer **ppIndexBuffer, __in_opt HANDLE* pUnusedSharedHandle);
|
|
HRESULT WINAPI CreateRenderTarget(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD UnusedMultisampleQuality, BOOL UnusedLockable, __deref_out D3DSurface **ppSurface, __in_opt CONST D3DSURFACE_PARAMETERS* pParameters);
|
|
HRESULT WINAPI CreateDepthStencilSurface(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD UnusedMultisampleQuality, BOOL UnusedDiscard, __deref_out D3DSurface **ppSurface, __in_opt CONST D3DSURFACE_PARAMETERS* pParameters);
|
|
D3DVOID WINAPI SetRenderTarget(DWORD RenderTargetIndex, __in_opt D3DSurface *pRenderTarget);
|
|
HRESULT WINAPI GetRenderTarget(DWORD RenderTargetIndex, __deref_out D3DSurface **ppRenderTarget);
|
|
D3DVOID WINAPI SetDepthStencilSurface(__in_opt D3DSurface *pZStencilSurface);
|
|
HRESULT WINAPI GetDepthStencilSurface(__deref_out D3DSurface **ppZStencilSurface);
|
|
HRESULT WINAPI GetBackBuffer(UINT UnusedSwapChain, UINT iUnusedBackBuffer, UINT UnusedType, __deref_out D3DSurface **ppBackBuffer);
|
|
HRESULT WINAPI GetFrontBuffer(__deref_out D3DTexture **ppFrontBuffer);
|
|
D3DVOID WINAPI BeginScene();
|
|
D3DVOID WINAPI EndScene();
|
|
D3DVOID WINAPI Clear(DWORD Count, __in_opt CONST D3DRECT *pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil);
|
|
D3DVOID WINAPI ClearF(DWORD Flags, __in_opt CONST D3DRECT *pRect, __in_opt CONST D3DVECTOR4* pColor, float Z, DWORD Stencil);
|
|
D3DVOID WINAPI SetViewport(__in CONST D3DVIEWPORT9 *pViewport);
|
|
D3DVOID WINAPI GetViewport(__out D3DVIEWPORT9 *pViewport);
|
|
D3DVOID WINAPI SetRenderState(D3DRENDERSTATETYPE State, DWORD Value);
|
|
D3DVOID WINAPI SetRenderState_Inline(D3DRENDERSTATETYPE State, DWORD Value);
|
|
D3DVOID WINAPI GetRenderState(D3DRENDERSTATETYPE State, __out DWORD *pValue);
|
|
HRESULT WINAPI CreateStateBlock(D3DSTATEBLOCKTYPE Type, __deref_out D3DStateBlock** ppSB);
|
|
D3DVOID WINAPI GetTexture(DWORD Sampler, __deref_out D3DBaseTexture **ppTexture);
|
|
D3DVOID WINAPI SetTexture(DWORD Sampler, __in_opt D3DBaseTexture *pTexture);
|
|
D3DVOID WINAPI GetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, __out DWORD* pValue);
|
|
D3DVOID WINAPI SetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value);
|
|
D3DVOID WINAPI SetSamplerState_Inline(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value);
|
|
D3DVOID WINAPI SetSamplerAddressStates(DWORD Sampler, DWORD AddressU, DWORD AddressV, DWORD AddressW);
|
|
D3DVOID WINAPI SetSamplerBorderStates(DWORD Sampler, DWORD BorderColor, DWORD WhiteBorderColorW, DWORD PointBorderEnable);
|
|
D3DVOID WINAPI SetSamplerSeparateZFilterStates(DWORD Sampler, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter, DWORD MinFilterZ, DWORD MagFilterZ, DWORD MaxAnisotropy);
|
|
D3DVOID WINAPI SetSamplerFilterStates(DWORD Sampler, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter, DWORD MaxAnisotropy);
|
|
D3DVOID WINAPI DrawVertices(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT VertexCount);
|
|
D3DVOID WINAPI DrawIndexedVertices(D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT StartIndex, UINT IndexCount);
|
|
D3DVOID WINAPI DrawVerticesUP(D3DPRIMITIVETYPE PrimitiveType, UINT VertexCount, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride);
|
|
D3DVOID WINAPI DrawIndexedVerticesUP(D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertices, UINT IndexCount, __in CONST void *pIndexData, D3DFORMAT IndexDataFormat, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride);
|
|
D3DVOID WINAPI DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount);
|
|
D3DVOID WINAPI DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT UnusedMinIndex, UINT UnusedNumIndices, UINT StartIndex, UINT PrimitiveCount);
|
|
D3DVOID WINAPI DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride);
|
|
D3DVOID WINAPI DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT MinIndex, UINT NumVertices, UINT PrimitiveCount, __in CONST void *pIndexData, D3DFORMAT IndexDataFormat, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride);
|
|
D3DVOID WINAPI SetFVF(DWORD FVF);
|
|
D3DVOID WINAPI GetFVF(__out DWORD* pFVF);
|
|
HRESULT WINAPI CreateVertexShader(__in CONST DWORD *pFunction, __deref_out D3DVertexShader** ppShader);
|
|
D3DVOID WINAPI SetVertexShader(__in_opt D3DVertexShader *pShader);
|
|
D3DVOID WINAPI GetVertexShader(__deref_out D3DVertexShader **ppShader);
|
|
D3DVOID WINAPI SetVertexShaderConstantB(UINT StartRegister, __in_ecount(BoolCount) CONST BOOL *pConstantData, UINT BoolCount);
|
|
D3DVOID WINAPI SetVertexShaderConstantF(UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount);
|
|
D3DVOID WINAPI SetVertexShaderConstantI(UINT StartRegister, __in_ecount(4*Vector4iCount) CONST int *pConstantData, DWORD Vector4iCount);
|
|
D3DVOID WINAPI GetVertexShaderConstantB(UINT StartRegister, __out_ecount(BoolCount) BOOL *pConstantData, DWORD BoolCount);
|
|
D3DVOID WINAPI GetVertexShaderConstantF(UINT StartRegister, __out_ecount(4*Vector4fCount) float *pConstantData, DWORD Vector4fCount);
|
|
D3DVOID WINAPI GetVertexShaderConstantI(UINT StartRegister, __out_ecount(4*Vector4iCount) int *pConstantData, DWORD Vector4iCount);
|
|
D3DVOID WINAPI SetVertexShaderConstantF_NotInline(UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount);
|
|
D3DVOID WINAPI SetStreamSource(UINT StreamNumber, __in_opt D3DVertexBuffer *pStreamData, UINT OffsetInBytes, UINT Stride);
|
|
D3DVOID WINAPI GetStreamSource(UINT StreamNumber, __deref_out D3DVertexBuffer **ppStreamData, __out UINT *pOffsetInBytes, __out UINT *pStride);
|
|
D3DVOID WINAPI SetIndices(__in_opt D3DIndexBuffer *pIndexData);
|
|
D3DVOID WINAPI GetIndices(__deref_out D3DIndexBuffer **ppIndexData);
|
|
HRESULT WINAPI CreatePixelShader(__in CONST DWORD *pFunction, __deref_out D3DPixelShader** ppShader);
|
|
D3DVOID WINAPI SetPixelShader(__in_opt D3DPixelShader* pShader);
|
|
D3DVOID WINAPI GetPixelShader(__deref_out D3DPixelShader** ppShader);
|
|
D3DVOID WINAPI SetPixelShaderConstantB(UINT StartRegister, __in_ecount(BoolCount) CONST BOOL *pConstantData, UINT BoolCount);
|
|
D3DVOID WINAPI SetPixelShaderConstantF(UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount);
|
|
D3DVOID WINAPI SetPixelShaderConstantI(UINT StartRegister, __in_ecount(4*Vector4iCount) CONST int *pConstantData, DWORD Vector4iCount);
|
|
D3DVOID WINAPI GetPixelShaderConstantB(UINT StartRegister, __out_ecount(BoolCount) BOOL *pConstantData, DWORD BoolCount);
|
|
D3DVOID WINAPI GetPixelShaderConstantF(UINT StartRegister, __out_ecount(4*Vector4fCount) float *pConstantData, DWORD Vector4fCount);
|
|
D3DVOID WINAPI GetPixelShaderConstantI(UINT StartRegister, __out_ecount(4*Vector4iCount) int *pConstantData, DWORD Vector4iCount);
|
|
D3DVOID WINAPI SetPixelShaderConstantF_NotInline(UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount);
|
|
HRESULT WINAPI CreateVertexDeclaration(__in CONST D3DVERTEXELEMENT9* pVertexElements, __deref_out D3DVertexDeclaration **ppVertexDeclaration);
|
|
D3DVOID WINAPI SetVertexDeclaration(__in_opt D3DVertexDeclaration *pDecl);
|
|
D3DVOID WINAPI GetVertexDeclaration(__deref_out D3DVertexDeclaration **ppDecl);
|
|
D3DVOID WINAPI SetScissorRect(__in CONST RECT* pRect);
|
|
D3DVOID WINAPI GetScissorRect(__out RECT* pRect);
|
|
D3DVOID WINAPI SetClipPlane(DWORD Index, __in_ecount(4) CONST float* pPlane);
|
|
D3DVOID WINAPI GetClipPlane(DWORD Index, __out_ecount(4) float* pPlane);
|
|
HRESULT WINAPI CreateQuery(D3DQUERYTYPE Type, __deref_out D3DQuery** ppQuery);
|
|
|
|
// The following APIs are all Xbox 360 extensions:
|
|
|
|
HRESULT WINAPI CreateQueryTiled(D3DQUERYTYPE Type, DWORD TileCount, __deref_out D3DQuery** ppQuery);
|
|
D3DVOID WINAPI Resolve(DWORD Flags, __in_opt CONST D3DRECT *pSourceRect, __in D3DBaseTexture *pDestTexture, __in_opt CONST D3DPOINT *pDestPoint, UINT DestLevel, UINT DestSliceOrFace, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil, __in_opt CONST D3DRESOLVE_PARAMETERS* pParameters);
|
|
D3DVOID WINAPI AcquireThreadOwnership();
|
|
D3DVOID WINAPI ReleaseThreadOwnership();
|
|
D3DVOID WINAPI SetThreadOwnership(DWORD ThreadID);
|
|
DWORD WINAPI QueryThreadOwnership();
|
|
BOOL WINAPI IsBusy();
|
|
D3DVOID WINAPI BlockUntilIdle();
|
|
D3DVOID WINAPI InsertCallback(D3DCALLBACKTYPE Type, __in_opt D3DCALLBACK pCallback, DWORD Context);
|
|
D3DVOID WINAPI SetVerticalBlankCallback(__in_opt D3DVBLANKCALLBACK pCallback);
|
|
D3DVOID WINAPI SetSwapCallback(__in D3DSWAPCALLBACK pCallback);
|
|
D3DVOID WINAPI SynchronizeToPresentationInterval();
|
|
D3DVOID WINAPI Swap(__in D3DBaseTexture* pFrontBuffer, __in_opt CONST D3DVIDEO_SCALER_PARAMETERS* pParameters);
|
|
D3DVOID WINAPI RenderSystemUI();
|
|
D3DVOID WINAPI QueryBufferSpace(__out DWORD* pUsed, __out DWORD* pRemaining);
|
|
D3DVOID WINAPI SetPredication(DWORD PredicationMask);
|
|
D3DVOID WINAPI SetPatchablePredication(DWORD PredicationMask, DWORD Identifier);
|
|
D3DVOID WINAPI BeginTiling(DWORD Flags, DWORD Count, __in_ecount(Count) CONST D3DRECT* pTileRects, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil);
|
|
HRESULT WINAPI EndTiling(DWORD ResolveFlags, __in_opt CONST D3DRECT* pResolveRects, __in_opt D3DBaseTexture* pDestTexture, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil, __in_opt CONST D3DRESOLVE_PARAMETERS* pParameters);
|
|
D3DVOID WINAPI BeginZPass(DWORD Flags);
|
|
HRESULT WINAPI EndZPass();
|
|
HRESULT WINAPI InvokeRenderPass();
|
|
D3DVOID WINAPI BeginExport(DWORD Index, __in D3DResource* pResource, DWORD Flags);
|
|
D3DVOID WINAPI EndExport(DWORD Index, __in D3DResource* pResource, DWORD Flags);
|
|
D3DVOID WINAPI DrawTessellatedPrimitive(D3DTESSPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount);
|
|
D3DVOID WINAPI DrawIndexedTessellatedPrimitive(D3DTESSPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT StartIndex, UINT PrimitiveCount);
|
|
HRESULT WINAPI SetRingBufferParameters(__in_opt CONST D3DRING_BUFFER_PARAMETERS *pParameters);
|
|
D3DVOID WINAPI XpsBegin(DWORD Flags);
|
|
HRESULT WINAPI XpsEnd();
|
|
D3DVOID WINAPI XpsSetCallback(__in D3DXpsCallback pCallback, __in_opt void* pContext, DWORD Flags);
|
|
D3DVOID WINAPI XpsSubmit(DWORD InstanceCount, __in_bcount(Size) CONST void* pData, DWORD Size);
|
|
D3DVOID WINAPI XpsSetPredication(DWORD Predication);
|
|
D3DVOID WINAPI XpsSetPredicationFromVisibility(HANDLE VisibilityHandle);
|
|
D3DVOID WINAPI XpsSetPredicationFromQuery(__in_opt IDirect3DQuery9* pQuery);
|
|
HRESULT WINAPI BeginVertices(D3DPRIMITIVETYPE PrimitiveType, UINT VertexCount, UINT VertexStreamZeroStride, __deref_out_bcount(VertexCount*VertexStreamZeroStride) void**ppVertexData);
|
|
D3DVOID WINAPI EndVertices();
|
|
HRESULT WINAPI BeginIndexedVertices(D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT NumVertices, UINT IndexCount, D3DFORMAT IndexDataFormat, UINT VertexStreamZeroStride, __deref_out void** ppIndexData, __deref_out_bcount(NumVertices*VertexStreamZeroStride) void** ppVertexData);
|
|
D3DVOID WINAPI EndIndexedVertices();
|
|
DWORD WINAPI InsertFence();
|
|
D3DVOID WINAPI BlockOnFence(DWORD Fence);
|
|
BOOL WINAPI IsFencePending(DWORD Fence);
|
|
D3DVOID WINAPI SetBlendState(DWORD RenderTargetIndex, D3DBLENDSTATE BlendState);
|
|
D3DVOID WINAPI GetBlendState(DWORD RenderTargetIndex, __out D3DBLENDSTATE* pBlendState);
|
|
D3DVOID WINAPI SetVertexFetchConstant(UINT VertexFetchRegister, __in D3DVertexBuffer* pVertexBuffer, UINT Offset);
|
|
D3DVOID WINAPI SetTextureFetchConstant(UINT TextureFetchRegister, __in D3DBaseTexture* pTexture);
|
|
float WINAPI GetCounter(D3DCOUNTER CounterID);
|
|
D3DVOID WINAPI SetSafeLevel(DWORD Flags, DWORD Level);
|
|
D3DVOID WINAPI GetSafeLevel(DWORD* pFlags, __out DWORD* pLevel);
|
|
D3DVOID WINAPI SetHangCallback(D3DHANGCALLBACK pCallback);
|
|
D3DVOID WINAPI BeginConditionalSurvey(DWORD Identifier, DWORD Flags);
|
|
D3DVOID WINAPI EndConditionalSurvey(DWORD Flags);
|
|
D3DVOID WINAPI BeginConditionalRendering(DWORD Identifier);
|
|
D3DVOID WINAPI EndConditionalRendering();
|
|
HRESULT WINAPI PersistDisplay(__in D3DTexture* pFrontBuffer, __in_opt CONST D3DVIDEO_SCALER_PARAMETERS* pParameters);
|
|
HRESULT WINAPI GetPersistedTexture(__deref_out D3DTexture** pFrontBuffer);
|
|
D3DVOID WINAPI Suspend();
|
|
D3DVOID WINAPI Resume();
|
|
HRESULT WINAPI CreatePerfCounters(__deref_out D3DPerfCounters** ppCounters, UINT NumInstances);
|
|
D3DVOID WINAPI EnablePerfCounters(BOOL Enable);
|
|
D3DVOID WINAPI SetPerfCounterEvents(__in CONST D3DPERFCOUNTER_EVENTS* pEvents, DWORD Flags);
|
|
D3DVOID WINAPI QueryPerfCounters(__in D3DPerfCounters* pCounters, DWORD Flags);
|
|
DWORD WINAPI GetNumPasses();
|
|
D3DVOID WINAPI SetShaderInstructionAllocation(DWORD Flags, DWORD VertexShaderBase, DWORD PixelShaderBase);
|
|
D3DVOID WINAPI SetShaderGPRAllocation(DWORD Flags, DWORD VertexShaderCount, DWORD PixelShaderCount);
|
|
D3DVOID WINAPI GetShaderGPRAllocation(__out DWORD* pFlags, __out DWORD* pVertexShaderCount, __out DWORD* pPixelShaderCount);
|
|
D3DVOID WINAPI SetScreenExtentQueryMode(D3DSCREENEXTENTQUERYMODE Mode);
|
|
D3DVOID WINAPI GetScreenExtentQueryMode(__out D3DSCREENEXTENTQUERYMODE* pMode);
|
|
D3DVOID WINAPI BeginPixelShaderConstantF1(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, UINT Vector4fCount);
|
|
D3DVOID WINAPI EndPixelShaderConstantF1();
|
|
D3DVOID WINAPI BeginVertexShaderConstantF1(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, UINT Vector4fCount);
|
|
D3DVOID WINAPI EndVertexShaderConstantF1();
|
|
HRESULT WINAPI BeginPixelShaderConstantF4(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppCachedConstantData, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppWriteCombinedConstantData, UINT Vector4fCount);
|
|
D3DVOID WINAPI EndPixelShaderConstantF4();
|
|
HRESULT WINAPI BeginVertexShaderConstantF4(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppCachedConstantData, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppWriteCombinedConstantData, UINT Vector4fCount);
|
|
D3DVOID WINAPI EndVertexShaderConstantF4();
|
|
DWORD WINAPI GetCurrentFence();
|
|
D3DVOID WINAPI InvalidateGpuCache(__in_bcount(Size) void* pBaseAddress, DWORD Size, DWORD Flags);
|
|
D3DVOID WINAPI InvalidateResourceGpuCache(__in D3DResource* pResource, DWORD Flags);
|
|
D3DVOID WINAPI FlushHiZStencil(D3DFHZS_FLUSHTYPE FlushType);
|
|
D3DVOID WINAPI UnsetAll();
|
|
DWORD WINAPI GetDeviceState();
|
|
D3DVOID WINAPI SetBlockCallback(DWORD Flags, __in_opt D3DBLOCKCALLBACK pCallback);
|
|
D3DVOID WINAPI SetSurfaces(__in CONST D3DSURFACES* pSurfaces, DWORD Flags);
|
|
HRESULT WINAPI CreateConstantBuffer(UINT VectorCount, DWORD Usage, __deref_out D3DConstantBuffer **ppConstantBuffer);
|
|
HRESULT WINAPI CreateCommandBuffer(UINT Size, DWORD Flags, __deref_out D3DCommandBuffer **ppCommandBuffer);
|
|
HRESULT WINAPI CreateGrowableCommandBuffer(DWORD Flags, __in D3DALLOCATECALLBACK pAllocateCallback, __in D3DFREECALLBACK pFreeCallback, __in D3DQUERYCALLBACK pQueryCallback, DWORD CallbackContext, DWORD SegmentSize, __deref_out D3DCommandBuffer** ppCommandBuffer);
|
|
D3DVOID WINAPI BeginCommandBuffer(__in D3DCommandBuffer* pCommandBuffer, DWORD Flags, __in_opt CONST D3DTAGCOLLECTION* pInheritTags, __in_opt CONST D3DTAGCOLLECTION* pPersistTags, __in_opt CONST D3DRECT* pTilingRects, DWORD TileCount);
|
|
HRESULT WINAPI EndCommandBuffer();
|
|
D3DVOID WINAPI RunCommandBuffer(__in D3DCommandBuffer* pCommandBuffer, DWORD PredicationSelect);
|
|
HRESULT WINAPI InsertAsyncCommandBufferCall(__in D3DAsyncCommandBufferCall* pAsyncCommandBufferCall, DWORD PredicationSelect, DWORD Flags);
|
|
D3DVOID WINAPI SetCommandBufferPredication(DWORD TilePredication, DWORD RunPredication);
|
|
DWORD WINAPI InsertMarker();
|
|
D3DVOID WINAPI Nop(DWORD Count);
|
|
D3DVOID WINAPI QuerySwapStatus(__out D3DSWAP_STATUS* pSwapStatus);
|
|
DWORD WINAPI PixBeginNamedEvent(DWORD Color, __in_z CONST char *szName, ...);
|
|
DWORD WINAPI PixEndNamedEvent();
|
|
void WINAPI PixSetMarker(DWORD Color, __in_z CONST char *szName, ...);
|
|
void WINAPI PixIgnoreTexture(__in D3DBaseTexture* pTexture);
|
|
void WINAPI PixStopIgnoringTexture(__in D3DBaseTexture* pTexture);
|
|
void WINAPI PixIgnoreMemoryRange(__in_bcount(Size) const void* pBaseAddress, DWORD Size);
|
|
void WINAPI PixStopIgnoringMemoryRange(__in_bcount(Size) const void* pBaseAddress, DWORD Size);
|
|
HRESULT WINAPI PixSetTextureName(__in D3DBaseTexture* pTexture, __in_z const char* pName);
|
|
void WINAPI PixReportNewTexture(__in D3DBaseTexture* pTexture);
|
|
void WINAPI PixReportDeletedTexture(__in D3DBaseTexture* pTexture, BOOL BaseDeleted, BOOL MipDeleted);
|
|
void WINAPI PixReportMovedMemoryRange(__in_bcount(Size) const void* pDestinationAddress, __in_bcount(Size) const void* pSourceAddress, DWORD Size);
|
|
void WINAPI PixReportFreedMemoryRange(__in_bcount(Size) const void* pAddress, DWORD Size);
|
|
D3DVOID WINAPI SetViewportF(__in CONST D3DVIEWPORTF9* pViewportF);
|
|
D3DVOID WINAPI GetViewportF(__out D3DVIEWPORTF9* pViewportF);
|
|
HANDLE WINAPI BeginVisibilitySurvey(DWORD Flags);
|
|
D3DVOID WINAPI EndVisibilitySurvey(HANDLE VisibilityHandle);
|
|
D3DVOID WINAPI SetSwapMode(BOOL Asynchronous);
|
|
D3DASYNCBLOCK WINAPI InsertBlockOnAsyncResources(DWORD WriteCount, __in_ecount_opt(WriteCount) D3DResource* CONST* pWriteResourceList, DWORD ReadCount, __in_ecount_opt(ReadCount) D3DResource* CONST* pReadResourceList, DWORD Flags);
|
|
D3DVOID WINAPI SignalAsyncResources(D3DASYNCBLOCK AsyncBlock);
|
|
HRESULT WINAPI CreateAsyncCommandBufferCall(__in_opt D3DTAGCOLLECTION* pInheritTags, __in_opt D3DTAGCOLLECTION* pPersistTags, DWORD NumSegments, DWORD Flags, D3DAsyncCommandBufferCall** ppAsyncCall);
|
|
HRESULT WINAPI CreatePerfCounterBatch(UINT NumSlots, UINT NumTiles, DWORD Flags, __deref_out D3DPerfCounterBatch** ppBatch);
|
|
HRESULT WINAPI CreateOcclusionQueryBatch(UINT NumSlots, UINT NumTiles, __deref_out D3DOcclusionQueryBatch** ppBatch);
|
|
|
|
// The following methods are not supported on Xbox 360:
|
|
//
|
|
// TestCooperativeLevel
|
|
// GetAvailableTextureMemory
|
|
// EvictManagedResources
|
|
// SetCursorProperties
|
|
// SetCursorPosition
|
|
// ShowCursor
|
|
// CreateAdditionalSwapChain
|
|
// GetSwapChain
|
|
// GetNumberOfSwapChains
|
|
// SetDialogBoxMode
|
|
// UpdateSurface
|
|
// UpdateTexture
|
|
// GetRenderTargetData
|
|
// GetFrontBufferData
|
|
// StretchRect
|
|
// ColorFill
|
|
// CreateOffscreenPlainSurface
|
|
// ValidateDevice
|
|
// SetPaletteEntries
|
|
// GetPaletteEntries
|
|
// SetCurrentTexturePalette
|
|
// GetCurrentTexturePalette
|
|
// SetSoftwareVertexProcessing
|
|
// GetSoftwareVertexProcessing
|
|
// ProcessVertices
|
|
// BeginStateBlock
|
|
// EndStateBlock
|
|
// SetClipStatus
|
|
// GetClipStatus
|
|
|
|
// Unbuffered 'Gpu' APIs:
|
|
//
|
|
// Most Xbox 360 D3D APIs defer the sending of modified state to the GPU
|
|
// until a Draw API is called. The following APIs are different in that
|
|
// they are unbuffered and so immediately send modified state to the GPU
|
|
// when the API is called.
|
|
|
|
void WINAPI GpuOwn(D3DTAG Tag);
|
|
void WINAPI GpuOwnSubset(D3DTAG Tag, DWORD StartIndex, DWORD EndIndex);
|
|
void WINAPI GpuOwnVertexShaderConstantF(DWORD StartRegister, DWORD Vector4fCount);
|
|
void WINAPI GpuOwnPixelShaderConstantF(DWORD StartRegister, DWORD Vector4fCount);
|
|
void WINAPI GpuOwnShaders();
|
|
void WINAPI GpuDisown(D3DTAG Tag);
|
|
void WINAPI GpuDisownSubset(D3DTAG Tag, DWORD StartIndex, DWORD EndIndex);
|
|
void WINAPI GpuDisownVertexShaderConstantF(DWORD StartRegister, DWORD Vector4fCount);
|
|
void WINAPI GpuDisownPixelShaderConstantF(DWORD StartRegister, DWORD Vector4fCount);
|
|
void WINAPI GpuDisownShaders();
|
|
void WINAPI GpuDisownAll();
|
|
void WINAPI GpuLoadPixelShaderConstantF4(UINT StartRegister, DWORD Vector4fCount, __in D3DConstantBuffer* pConstantBuffer, DWORD OffsetInVectors);
|
|
void WINAPI GpuLoadVertexShaderConstantF4(UINT StartRegister, DWORD Vector4fCount, __in D3DConstantBuffer* pConstantBuffer, DWORD OffsetInVectors);
|
|
void WINAPI GpuLoadPixelShaderConstantF4Pointer(UINT StartRegister, __in_bcount(4*sizeof(FLOAT)*Vector4fCount) CONST void* pConstantData, DWORD Vector4fCount);
|
|
void WINAPI GpuLoadVertexShaderConstantF4Pointer(UINT StartRegister, __in_bcount(4*sizeof(FLOAT)*Vector4fCount) CONST void* pConstantData, DWORD Vector4fCount);
|
|
HRESULT WINAPI GpuBeginVertexShaderConstantF4(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, DWORD Vector4fCount);
|
|
void WINAPI GpuEndVertexShaderConstantF4();
|
|
HRESULT WINAPI GpuBeginPixelShaderConstantF4(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, DWORD Vector4fCount);
|
|
void WINAPI GpuEndPixelShaderConstantF4();
|
|
void WINAPI GpuLoadShaders(__in D3DVertexShader* pVertexShader, __in_opt D3DPixelShader* pPixelShader, __in_opt CONST GPUFLOW_CONSTANTS* pFlowConstants);
|
|
void WINAPI GpuLoadShadersFast(__in D3DVertexShader* pVertexShader, __in_opt D3DPixelShader* pPixelShader, __in_opt CONST GPUFLOW_CONSTANTS* pFlowConstants, DWORD Flags);
|
|
void WINAPI GpuSetVertexFetchConstant(DWORD VertexFetchRegister, __in_opt D3DVertexBuffer* pVertexBuffer0, DWORD OffsetInBytes0, __in_opt D3DVertexBuffer* pVertexBuffer1, DWORD OffsetInBytes1, __in_opt D3DVertexBuffer* pVertexBuffer2, DWORD OffsetInBytes2);
|
|
void WINAPI GpuSetTextureFetchConstant(DWORD TextureFetchRegister, __in D3DBaseTexture* pTexture);
|
|
void WINAPI GpuSetColorMask(__in const GPU_COLORMASK* pColorMask);
|
|
void WINAPI GpuSetBlendFactor(__in const D3DCOLORVALUE* pColor);
|
|
void WINAPI GpuSetAlphaRef(float Ref);
|
|
void WINAPI GpuSetBlendControl(DWORD RenderTargetIndex, __in const GPU_BLENDCONTROL* pBlendControl);
|
|
void WINAPI GpuSetColorControl(__in const GPU_COLORCONTROL* pColorControl);
|
|
|
|
#endif __cplusplus
|
|
|
|
// Tracks all GPU registers that are pending to be set at the next Draw
|
|
// calls. These are essentially 'Lazy' flags for all GPU context state.
|
|
// Only registers that are not 'owned' by the 'Gpu' APIs can be pending.
|
|
//
|
|
D3DTAGCOLLECTION m_Pending;
|
|
|
|
// To support the automatic Z prepass, some register writes have to
|
|
// be predicated. The following mask is used internally by D3D to catch
|
|
// updates to those registers, which all come from m_Pending.m_Mask[2]:
|
|
//
|
|
UINT64 m_Predicated_PendingMask2;
|
|
|
|
// 'm_pRing' points one dword BEFORE the location in the ring-buffer
|
|
// or command buffer where the next GPU command will be added. It's one
|
|
// dword before so that we can use 'storewordupdate(dword, 4, pCommand)'/
|
|
// 'storefloatupdate(float, 4, pCommand)' for most of our buffer writes,
|
|
// which is a nifty PPC trick that does a store and auto-increment in one
|
|
// instruction. The only caveat is that it's a pre-increment...
|
|
//
|
|
// (The 'storewordupdate/storefloatupdate' trick has the other nice
|
|
// attribute in that it forces the compiler to strongly order all writes
|
|
// to the ring-buffer, which is important since all writes to write-combined
|
|
// have to be perfectly consecutive in order to write-combine.)
|
|
//
|
|
PRING m_pRing;
|
|
|
|
// 'm_pRingLimit' points to the end of the current secondary ring buffer
|
|
// segment.
|
|
//
|
|
PRING m_pRingLimit;
|
|
|
|
// If 'm_pRing' is less than 'm_pRingGuarantee', it's guaranteed that
|
|
// there are at least 32 dwords of room in the segment.
|
|
//
|
|
PRING m_pRingGuarantee;
|
|
|
|
// Reference count on the current device.
|
|
//
|
|
DWORD m_ReferenceCount;
|
|
|
|
// Table of function pointers to specific state APIs.
|
|
//
|
|
D3DSETRENDERSTATECALL m_SetRenderStateCall[D3DRS_MAX/4];
|
|
D3DSETSAMPLERSTATECALL m_SetSamplerStateCall[D3DSAMP_MAX/4];
|
|
D3DGETRENDERSTATECALL m_GetRenderStateCall[D3DRS_MAX/4];
|
|
D3DGETSAMPLERSTATECALL m_GetSamplerStateCall[D3DSAMP_MAX/4];
|
|
|
|
// Shadow of all GPU constants. Ensure that the beginning of the ALU
|
|
// constant array is 128-byte aligned.
|
|
//
|
|
__declspec(align(128)) D3DConstants m_Constants;
|
|
|
|
// Shadow of all GPU render states. If updating a value in the shadow
|
|
// directly, be sure to also set the appropriate flag in 'm_Pending'
|
|
// so that the GPU's version of the state gets updated.
|
|
//
|
|
float m_ClipPlanes[D3DMAXUSERCLIPPLANES][4];
|
|
|
|
GPU_DESTINATIONPACKET m_DestinationPacket;
|
|
GPU_WINDOWPACKET m_WindowPacket; // Special, never set via 'm_Pending'
|
|
GPU_VALUESPACKET m_ValuesPacket;
|
|
GPU_PROGRAMPACKET m_ProgramPacket;
|
|
GPU_CONTROLPACKET m_ControlPacket;
|
|
GPU_TESSELLATORPACKET m_TessellatorPacket;
|
|
GPU_MISCPACKET m_MiscPacket;
|
|
GPU_POINTPACKET m_PointPacket;
|
|
|
|
// Shadow sampler states for GetSamplerState
|
|
//
|
|
BYTE m_MaxAnisotropy[D3DSAMP_MAXSAMPLERS];
|
|
BYTE m_ZFilter[D3DSAMP_MAXSAMPLERS];
|
|
};
|
|
|
|
/*
|
|
* C exported method definitions for the class methods defined above and the C++
|
|
* thunks that defer to them.
|
|
*/
|
|
|
|
/* Direct3D */
|
|
|
|
D3DINLINE ULONG WINAPI Direct3D_AddRef() { return 1; }
|
|
D3DINLINE ULONG WINAPI Direct3D_Release() { return 1; }
|
|
D3DINLINE UINT WINAPI Direct3D_GetAdapterCount() { return 1; }
|
|
HRESULT WINAPI Direct3D_GetAdapterIdentifier(UINT Adapter, DWORD Flags, __out D3DADAPTER_IDENTIFIER9 *pIdentifier);
|
|
HRESULT WINAPI Direct3D_CheckDeviceType(UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL Windowed);
|
|
HRESULT WINAPI Direct3D_CheckDeviceFormat(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat);
|
|
HRESULT WINAPI Direct3D_CheckDeviceMultiSampleType(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType, __out_opt DWORD* pQualityLevels);
|
|
HRESULT WINAPI Direct3D_CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat);
|
|
HRESULT WINAPI Direct3D_CheckDeviceFormatConversion(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat);
|
|
HRESULT WINAPI Direct3D_GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,__out D3DCAPS9 *pCaps);
|
|
HRESULT WINAPI Direct3D_CreateDevice(UINT Adapter, D3DDEVTYPE DeviceType, __in_opt void *hUnusedFocusWindow, DWORD BehaviorFlags, __in_opt D3DPRESENT_PARAMETERS *pPresentationParameters, __deref_out D3DDevice **ppReturnedDeviceInterface);
|
|
void WINAPI Direct3D_QueryGpuVersion(__out D3DGPUVERSION* pGpuVersion);
|
|
|
|
|
|
// Compatibility wrappers.
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3D9_AddRef(__in Direct3D *pThis) { return Direct3D_AddRef(); }
|
|
D3DINLINE ULONG WINAPI IDirect3D9_Release(__in Direct3D *pThis) { return Direct3D_Release(); }
|
|
D3DINLINE UINT WINAPI IDirect3D9_GetAdapterCount(__in Direct3D *pThis) { return Direct3D_GetAdapterCount(); }
|
|
D3DINLINE HRESULT WINAPI IDirect3D9_GetAdapterIdentifier(__in Direct3D *pThis, UINT Adapter, DWORD Flags, __out D3DADAPTER_IDENTIFIER9 *pIdentifier) { return Direct3D_GetAdapterIdentifier(Adapter, Flags, pIdentifier); }
|
|
D3DINLINE HRESULT WINAPI IDirect3D9_CheckDeviceType(__in Direct3D *pThis, UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL Windowed) { return Direct3D_CheckDeviceType(Adapter, CheckType, DisplayFormat, BackBufferFormat, Windowed); }
|
|
D3DINLINE HRESULT WINAPI IDirect3D9_CheckDeviceFormat(__in Direct3D *pThis, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) { return Direct3D_CheckDeviceFormat(Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat); }
|
|
D3DINLINE HRESULT WINAPI IDirect3D9_CheckDeviceMultiSampleType(__in Direct3D *pThis, UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType, __out_opt DWORD* pQualityLevels) { return Direct3D_CheckDeviceMultiSampleType(Adapter, DeviceType, SurfaceFormat, Windowed, MultiSampleType, pQualityLevels); }
|
|
D3DINLINE HRESULT WINAPI IDirect3D9_CheckDepthStencilMatch(__in Direct3D *pThis, UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat) { return Direct3D_CheckDepthStencilMatch(Adapter, DeviceType, AdapterFormat, RenderTargetFormat, DepthStencilFormat); }
|
|
D3DINLINE HRESULT WINAPI IDirect3D9_CheckDeviceFormatConversion(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat) { return Direct3D_CheckDeviceFormatConversion(Adapter, DeviceType, SourceFormat, TargetFormat); }
|
|
D3DINLINE HRESULT WINAPI IDirect3D9_GetDeviceCaps(__in Direct3D *pThis, UINT Adapter,D3DDEVTYPE DeviceType,__out D3DCAPS9 *pCaps) { return Direct3D_GetDeviceCaps(Adapter, DeviceType, pCaps); }
|
|
D3DINLINE HRESULT WINAPI IDirect3D9_CreateDevice(__in Direct3D *pThis, UINT Adapter, D3DDEVTYPE DeviceType, __in_opt void *hUnusedFocusWindow, DWORD BehaviorFlags, __in_opt D3DPRESENT_PARAMETERS *pPresentationParameters, __deref_out D3DDevice **ppReturnedDeviceInterface) { return Direct3D_CreateDevice(Adapter, DeviceType, hUnusedFocusWindow, BehaviorFlags, pPresentationParameters, ppReturnedDeviceInterface); }
|
|
D3DINLINE void WINAPI IDirect3D9_QueryGpuVersion(__in Direct3D *pThis, __out D3DGPUVERSION* pGpuVersion) { Direct3D_QueryGpuVersion(pGpuVersion); }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE ULONG WINAPI Direct3D::AddRef() { return Direct3D_AddRef(); }
|
|
D3DMINLINE ULONG WINAPI Direct3D::Release() { return Direct3D_Release(); }
|
|
D3DMINLINE UINT WINAPI Direct3D::GetAdapterCount() { return Direct3D_GetAdapterCount(); }
|
|
D3DMINLINE HRESULT WINAPI Direct3D::GetAdapterIdentifier(UINT Adapter, DWORD Flags, __out D3DADAPTER_IDENTIFIER9 *pIdentifier) { return Direct3D_GetAdapterIdentifier(Adapter, Flags, pIdentifier); }
|
|
D3DMINLINE HRESULT WINAPI Direct3D::CheckDeviceType(UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL Windowed) { return Direct3D_CheckDeviceType(Adapter, CheckType, DisplayFormat, BackBufferFormat, Windowed); }
|
|
D3DMINLINE HRESULT WINAPI Direct3D::CheckDeviceFormat(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) { return Direct3D_CheckDeviceFormat(Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat); }
|
|
D3DMINLINE HRESULT WINAPI Direct3D::CheckDeviceMultiSampleType(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType, __out_opt DWORD* pQualityLevels) { return Direct3D_CheckDeviceMultiSampleType(Adapter, DeviceType, SurfaceFormat, Windowed, MultiSampleType, pQualityLevels); }
|
|
D3DMINLINE HRESULT WINAPI Direct3D::CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat) { return Direct3D_CheckDepthStencilMatch(Adapter, DeviceType, AdapterFormat, RenderTargetFormat, DepthStencilFormat); }
|
|
D3DMINLINE HRESULT WINAPI Direct3D::CheckDeviceFormatConversion(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat) { return Direct3D_CheckDeviceFormatConversion(Adapter, DeviceType, SourceFormat, TargetFormat); }
|
|
D3DMINLINE HRESULT WINAPI Direct3D::GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,__out D3DCAPS9 *pCaps) { return Direct3D_GetDeviceCaps(Adapter, DeviceType, pCaps); }
|
|
D3DMINLINE HRESULT WINAPI Direct3D::CreateDevice(UINT Adapter, D3DDEVTYPE DeviceType, __in_opt void *hUnusedFocusWindow, DWORD BehaviorFlags, __in_opt D3DPRESENT_PARAMETERS *pPresentationParameters, __deref_out D3DDevice **ppReturnedDeviceInterface) { return Direct3D_CreateDevice(Adapter, DeviceType, hUnusedFocusWindow, BehaviorFlags, pPresentationParameters, ppReturnedDeviceInterface); }
|
|
D3DMINLINE void WINAPI Direct3D::QueryGpuVersion(__out D3DGPUVERSION* pGpuVersion) { Direct3D_QueryGpuVersion(pGpuVersion); }
|
|
|
|
#endif __cplusplus
|
|
|
|
/****************************************************************************
|
|
*
|
|
* D3DDevice_*
|
|
*
|
|
* Private internal interfaces - Please don't access these directly, as they're
|
|
* subject to change.
|
|
*
|
|
****************************************************************************/
|
|
|
|
__out D3DVertexShader* WINAPI D3DDevice_CreateVertexShader(__in CONST DWORD *pFunction);
|
|
__out D3DPixelShader* WINAPI D3DDevice_CreatePixelShader(__in CONST DWORD *pFunction);
|
|
__out D3DBaseTexture* WINAPI D3DDevice_CreateTexture(DWORD Width, DWORD Height, DWORD Depth, DWORD Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, D3DRESOURCETYPE D3DType);
|
|
__out D3DSurface* WINAPI D3DDevice_CreateSurface(DWORD Width, DWORD Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, CONST D3DSURFACE_PARAMETERS* pParameters);
|
|
__out D3DVertexBuffer* WINAPI D3DDevice_CreateVertexBuffer(UINT Length, DWORD Usage, D3DPOOL UnusedPool);
|
|
__out D3DIndexBuffer* WINAPI D3DDevice_CreateIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool);
|
|
__out D3DVertexDeclaration* WINAPI D3DDevice_CreateVertexDeclaration(__in CONST D3DVERTEXELEMENT9* pVertexElements);
|
|
__out D3DConstantBuffer* WINAPI D3DDevice_CreateConstantBuffer(UINT VectorCount, DWORD Usage);
|
|
__out D3DCommandBuffer* WINAPI D3DDevice_CreateCommandBuffer(UINT Size, DWORD Flags);
|
|
__out D3DCommandBuffer* WINAPI D3DDevice_CreateGrowableCommandBuffer(DWORD Flags, __in D3DALLOCATECALLBACK pAllocateCallback, __in D3DFREECALLBACK pFreeCallback, __in D3DQUERYCALLBACK pQueryCallback, DWORD CallbackContext, DWORD SegmentSize);
|
|
__out D3DQuery* WINAPI D3DDevice_CreateQuery(__in D3DDevice *pDevice, D3DQUERYTYPE Type);
|
|
__out D3DQuery* WINAPI D3DDevice_CreateQueryTiled(__in D3DDevice *pDevice, D3DQUERYTYPE Type, DWORD TileCount);
|
|
__out D3DVertexDeclaration* WINAPI D3DDevice_GetVertexDeclaration(__in D3DDevice *pDevice);
|
|
__out D3DSurface* WINAPI D3DDevice_GetRenderTarget(__in D3DDevice *pDevice, DWORD RenderTargetIndex);
|
|
__out D3DSurface* WINAPI D3DDevice_GetDepthStencilSurface(__in D3DDevice *pDevice);
|
|
__out D3DSurface* WINAPI D3DDevice_GetBackBuffer(__in D3DDevice *pDevice);
|
|
__out D3DTexture* WINAPI D3DDevice_GetFrontBuffer(__in D3DDevice *pDevice);
|
|
__out D3DBaseTexture* WINAPI D3DDevice_GetTexture(__in D3DDevice *pDevice, DWORD Sampler);
|
|
__out D3DVertexBuffer* WINAPI D3DDevice_GetStreamSource(__in D3DDevice *pDevice, UINT StreamNumber, __out UINT *pOffsetInBytes, __out UINT *pStride);
|
|
__out D3DIndexBuffer* WINAPI D3DDevice_GetIndices(__in D3DDevice *pDevice);
|
|
__out D3DStateBlock* WINAPI D3DDevice_CreateStateBlock(__in D3DDevice* pDevice, D3DSTATEBLOCKTYPE Type);
|
|
__out D3DPerfCounters* WINAPI D3DDevice_CreatePerfCounters(__in D3DDevice *pDevice, UINT NumInstances);
|
|
__out D3DPerfCounterBatch* WINAPI D3DDevice_CreatePerfCounterBatch(__in D3DDevice* pDevice, UINT NumSlots, UINT NumTiles, DWORD Flags);
|
|
__out D3DOcclusionQueryBatch* WINAPI D3DDevice_CreateOcclusionQueryBatch(__in D3DDevice* pDevice, UINT NumSlots, UINT NumTiles);
|
|
|
|
ULONG WINAPI D3DDevice_AddRef(__in D3DDevice *pDevice);
|
|
ULONG WINAPI D3DDevice_Release(__in D3DDevice *pDevice);
|
|
void WINAPI D3DDevice_GetDirect3D(__in D3DDevice *pDevice, __deref_out Direct3D **ppD3D9);
|
|
void WINAPI D3DDevice_GetDeviceCaps(__in D3DDevice *pDevice, __out D3DCAPS9 *pCaps);
|
|
void WINAPI D3DDevice_GetDisplayMode(__in D3DDevice *pDevice, UINT UnusedSwapChain, __out D3DDISPLAYMODE *pMode);
|
|
void WINAPI D3DDevice_GetCreationParameters(__in D3DDevice *pDevice, __out D3DDEVICE_CREATION_PARAMETERS *pParameters);
|
|
HRESULT WINAPI D3DDevice_Reset(__in D3DDevice *pDevice, __in D3DPRESENT_PARAMETERS *pPresentationParameters);
|
|
void WINAPI D3DDevice_GetRasterStatus(__in D3DDevice *pDevice, __out D3DRASTER_STATUS *pRasterStatus);
|
|
void WINAPI D3DDevice_SetGammaRamp(__in D3DDevice *pDevice, DWORD UnusedFlags, __in CONST D3DGAMMARAMP *pRamp);
|
|
void WINAPI D3DDevice_GetGammaRamp(__in D3DDevice *pDevice, __out D3DGAMMARAMP *pRamp);
|
|
void WINAPI D3DDevice_SetPWLGamma(__in D3DDevice *pDevice, DWORD Flags, __in CONST D3DPWLGAMMA *pRamp);
|
|
void WINAPI D3DDevice_GetPWLGamma(__in D3DDevice *pDevice, __out D3DPWLGAMMA *pRamp);
|
|
void WINAPI D3DDevice_SetRenderTarget(__in D3DDevice *pDevice, DWORD RenderTargetIndex, __in_opt D3DSurface *pRenderTarget);
|
|
void WINAPI D3DDevice_SetRenderTarget_External(__in D3DDevice *pDevice, DWORD RenderTargetIndex, __in_opt D3DSurface *pRenderTarget);
|
|
void WINAPI D3DDevice_SetDepthStencilSurface(__in D3DDevice *pDevice, __in_opt D3DSurface *pZStencilSurface);
|
|
D3DINLINE void WINAPI D3DDevice_BeginScene(__in D3DDevice *pDevice) { }
|
|
D3DINLINE void WINAPI D3DDevice_EndScene(__in D3DDevice *pDevice) { }
|
|
void WINAPI D3DDevice_Clear(__in D3DDevice *pDevice, DWORD Count, __in_opt CONST D3DRECT *pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil, BOOL EDRAMClear);
|
|
void WINAPI D3DDevice_ClearF(__in D3DDevice *pDevice, DWORD Flags, __in_opt CONST D3DRECT *pRect, __in_opt CONST D3DVECTOR4* pColor, float Z, DWORD Stencil);
|
|
void WINAPI D3DDevice_SetViewport(__in D3DDevice *pDevice, __in CONST D3DVIEWPORT9 *pViewport);
|
|
void WINAPI D3DDevice_GetViewport(__in D3DDevice *pDevice, __out D3DVIEWPORT9 *pViewport);
|
|
void WINAPI D3DDevice_SetRenderState_ParameterCheck(__in D3DDevice *pDevice, D3DRENDERSTATETYPE State, DWORD Value);
|
|
void WINAPI D3DDevice_GetRenderState_ParameterCheck(__in D3DDevice *pDevice, D3DRENDERSTATETYPE State);
|
|
void WINAPI D3DDevice_SetSamplerState_ParameterCheck(__in D3DDevice *pDevice, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value);
|
|
void WINAPI D3DDevice_GetSamplerState_ParameterCheck(__in D3DDevice *pDevice, DWORD Sampler, D3DSAMPLERSTATETYPE Type);
|
|
void WINAPI D3DDevice_SetTexture(__in D3DDevice *pDevice, DWORD Sampler, __in_opt D3DBaseTexture *pTexture, UINT64 PendingMask3);
|
|
void WINAPI D3DDevice_DrawVertices(__in D3DDevice *pDevice, D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT VertexCount);
|
|
void WINAPI D3DDevice_DrawIndexedVertices(__in D3DDevice *pDevice, D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT StartIndex, UINT IndexCount);
|
|
void WINAPI D3DDevice_DrawVerticesUP(__in D3DDevice *pDevice, D3DPRIMITIVETYPE PrimitiveType, UINT VertexCount, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride);
|
|
void WINAPI D3DDevice_DrawIndexedVerticesUP(__in D3DDevice *pDevice, D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertices, UINT IndexCount, __in CONST void *pIndexData, D3DFORMAT IndexDataFormat, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride);
|
|
void WINAPI D3DDevice_SetVertexDeclaration(__in D3DDevice* pDevice, __in_opt D3DVertexDeclaration *pDecl);
|
|
void WINAPI D3DDevice_SetScissorRect(__in D3DDevice* pDevice, __in CONST RECT* pRect);
|
|
void WINAPI D3DDevice_GetScissorRect(__in D3DDevice* pDevice, __out RECT* pRect);
|
|
void WINAPI D3DDevice_SetFVF(__in D3DDevice *pDevice, DWORD FVF);
|
|
DWORD WINAPI D3DDevice_GetFVF(__in D3DDevice *pDevice);
|
|
void WINAPI D3DDevice_SetVertexShader(__in D3DDevice *pDevice, __in_opt D3DVertexShader *pShader);
|
|
void WINAPI D3DDevice_GetVertexShader(__in D3DDevice *pDevice, __deref_out D3DVertexShader **ppShader);
|
|
void WINAPI D3DDevice_SetVertexShaderConstantB(__in D3DDevice *pDevice, UINT StartRegister, __in_ecount(BoolCount) CONST BOOL *pConstantData, UINT BoolCount);
|
|
void WINAPI D3DDevice_SetVertexShaderConstantFN(__in D3DDevice *pDevice, UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount, UINT64 PendingMask0);
|
|
void WINAPI D3DDevice_SetVertexShaderConstantI(__in D3DDevice *pDevice, UINT StartRegister, __in_ecount(4*Vector4iCount) CONST int *pConstantData, DWORD Vector4iCount);
|
|
void WINAPI D3DDevice_GetVertexShaderConstantB(__in D3DDevice *pDevice, UINT StartRegister, __out_ecount(BoolCount) BOOL *pConstantData, DWORD BoolCount);
|
|
void WINAPI D3DDevice_GetVertexShaderConstantF(__in D3DDevice *pDevice, UINT StartRegister, __out_ecount(4*Vector4fCount) float *pConstantData, DWORD Vector4fCount);
|
|
void WINAPI D3DDevice_GetVertexShaderConstantI(__in D3DDevice *pDevice, UINT StartRegister, __out_ecount(4*Vector4iCount) int *pConstantData, DWORD Vector4iCount);
|
|
void WINAPI D3DDevice_SetVertexShaderConstantF_ParameterCheck(__in D3DDevice* pDevice, UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount);
|
|
void WINAPI D3DDevice_SetStreamSource(__in D3DDevice *pDevice, UINT StreamNumber, __in_opt D3DVertexBuffer *pStreamData, UINT OffsetInBytes, UINT Stride, UINT64 PendingMask3);
|
|
void WINAPI D3DDevice_SetIndices(__in D3DDevice *pDevice, __in_opt D3DIndexBuffer *pIndexData);
|
|
void WINAPI D3DDevice_SetPixelShader(__in D3DDevice *pDevice, __in_opt D3DPixelShader* pShader);
|
|
void WINAPI D3DDevice_GetPixelShader(__in D3DDevice *pDevice, __deref_out D3DPixelShader** ppShader);
|
|
void WINAPI D3DDevice_SetPixelShaderConstantB(__in D3DDevice *pDevice, UINT StartRegister, __in_ecount(BoolCount) CONST BOOL *pConstantData, UINT BoolCount);
|
|
void WINAPI D3DDevice_SetPixelShaderConstantFN(__in D3DDevice *pDevice, UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount, UINT64 PendingMask1);
|
|
void WINAPI D3DDevice_SetPixelShaderConstantI(__in D3DDevice *pDevice, UINT StartRegister, __in_ecount(4*Vector4iCount) CONST int *pConstantData, DWORD Vector4iCount);
|
|
void WINAPI D3DDevice_GetPixelShaderConstantB(__in D3DDevice *pDevice, UINT StartRegister, __out_ecount(BoolCount) BOOL *pConstantData, DWORD BoolCount);
|
|
void WINAPI D3DDevice_GetPixelShaderConstantF(__in D3DDevice *pDevice, UINT StartRegister, __out_ecount(4*Vector4fCount) float *pConstantData, DWORD Vector4fCount);
|
|
void WINAPI D3DDevice_GetPixelShaderConstantI(__in D3DDevice *pDevice, UINT StartRegister, __out_ecount(4*Vector4iCount) int *pConstantData, DWORD Vector4iCount);
|
|
void WINAPI D3DDevice_SetPixelShaderConstantF_ParameterCheck(__in D3DDevice* pDevice, UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount);
|
|
void WINAPI D3DDevice_SetClipPlane(__in D3DDevice *pDevice, DWORD Index, __in_ecount(4) CONST float* pPlane);
|
|
void WINAPI D3DDevice_GetClipPlane(__in D3DDevice *pDevice, DWORD Index, __out_ecount(4) float* pPlane);
|
|
|
|
void WINAPI D3DDevice_Resolve(__in D3DDevice* pDevice, DWORD Flags, __in_opt CONST D3DRECT *pSourceRect, __in D3DBaseTexture *pDestTexture, __in_opt CONST D3DPOINT *pDestPoint, UINT DestLevel, UINT DestSliceOrFace, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil, __in_opt CONST D3DRESOLVE_PARAMETERS* pParameters);
|
|
void WINAPI D3DDevice_AcquireThreadOwnership(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_ReleaseThreadOwnership(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_SetThreadOwnership(__in D3DDevice* pDevice, DWORD ThreadID);
|
|
DWORD WINAPI D3DDevice_QueryThreadOwnership(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_Present(__in D3DDevice *pDevice);
|
|
BOOL WINAPI D3DDevice_IsBusy(__in D3DDevice *pDevice);
|
|
void WINAPI D3DDevice_BlockUntilIdle(__in D3DDevice *pDevice);
|
|
void WINAPI D3DDevice_InsertCallback(__in D3DDevice *pDevice, D3DCALLBACKTYPE Type, __in_opt D3DCALLBACK pCallback, DWORD Context);
|
|
void WINAPI D3DDevice_SetVerticalBlankCallback(__in D3DDevice *pDevice, __in_opt D3DVBLANKCALLBACK pCallback);
|
|
void WINAPI D3DDevice_SetSwapCallback(__in D3DDevice *pDevice, __in D3DSWAPCALLBACK pCallback);
|
|
void WINAPI D3DDevice_SynchronizeToPresentationInterval(__in D3DDevice *pDevice);
|
|
void WINAPI D3DDevice_Swap(__in D3DDevice *pDevice, __in D3DBaseTexture* pFrontBuffer, __in_opt CONST D3DVIDEO_SCALER_PARAMETERS* pParameters);
|
|
void WINAPI D3DDevice_RenderSystemUI(__in D3DDevice *pDevice);
|
|
void WINAPI D3DDevice_QueryBufferSpace(__in D3DDevice* pDevice, __out DWORD* pUsed, __out DWORD* pRemaining);
|
|
void WINAPI D3DDevice_SetPredication(__in D3DDevice* pDevice, DWORD PredicationMask);
|
|
void WINAPI D3DDevice_SetPatchablePredication(__in D3DDevice* pDevice, DWORD PredicationMask, DWORD Identifier);
|
|
void WINAPI D3DDevice_BeginTiling(__in D3DDevice* pDevice, DWORD Flags, DWORD Count, __in_ecount(Count) CONST D3DRECT* pTileRects, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil);
|
|
HRESULT WINAPI D3DDevice_EndTiling(__in D3DDevice* pDevice, DWORD ResolveFlags, __in_opt CONST D3DRECT* pResolveRects, __in_opt D3DBaseTexture* pDestTexture, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil, __in_opt CONST D3DRESOLVE_PARAMETERS* pParameters);
|
|
void WINAPI D3DDevice_BeginZPass(__in D3DDevice* pDevice, DWORD Flags);
|
|
HRESULT WINAPI D3DDevice_EndZPass(__in D3DDevice* pDevice);
|
|
HRESULT WINAPI D3DDevice_InvokeRenderPass(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_BeginExport(__in D3DDevice* pDevice, DWORD Index, __in D3DResource* pResource, DWORD Flags);
|
|
void WINAPI D3DDevice_EndExport(__in D3DDevice* pDevice, DWORD Index, __in D3DResource* pResource, DWORD Flags);
|
|
void WINAPI D3DDevice_DrawTessellatedVertices(__in D3DDevice *pDevice, D3DTESSPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT VertexCount);
|
|
void WINAPI D3DDevice_DrawIndexedTessellatedVertices(__in D3DDevice *pDevice, D3DTESSPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT StartIndex, UINT IndexCount);
|
|
HRESULT WINAPI D3DDevice_SetRingBufferParameters(__in D3DDevice* pDevice, __in_opt CONST D3DRING_BUFFER_PARAMETERS *pParameters);
|
|
void WINAPI D3DDevice_XpsBegin(__in D3DDevice* pDevice, DWORD Flags);
|
|
HRESULT WINAPI D3DDevice_XpsEnd(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_XpsSetCallback(__in D3DDevice* pDevice, __in D3DXpsCallback pCallback, __in_opt void* pContext, DWORD Flags);
|
|
void WINAPI D3DDevice_XpsSubmit(__in D3DDevice* pDevice, DWORD InstanceCount, __in_bcount(Size) CONST void* pData, DWORD Size);
|
|
void WINAPI D3DDevice_XpsSetPredication(__in D3DDevice* pDevice, DWORD Predication);
|
|
void WINAPI D3DDevice_XpsSetPredicationFromVisibility(__in D3DDevice* pDevice, HANDLE VisibilityHandle);
|
|
void WINAPI D3DDevice_XpsSetPredicationFromQuery(__in D3DDevice* pDevice, __in_opt IDirect3DQuery9* pQuery);
|
|
__out_bcount(VertexCount*VertexStreamZeroStride) void* WINAPI D3DDevice_BeginVertices(__in D3DDevice *pDevice, D3DPRIMITIVETYPE PrimitiveType, UINT VertexCount, UINT VertexStreamZeroStride);
|
|
void WINAPI D3DDevice_EndVertices(__in D3DDevice *pDevice);
|
|
HRESULT WINAPI D3DDevice_BeginIndexedVertices(__in D3DDevice *pDevice, D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT NumVertices, UINT IndexCount, D3DFORMAT IndexDataFormat, UINT VertexStreamZeroStride, __deref_out void** ppIndexData, __deref_out_bcount(NumVertices*VertexStreamZeroStride) void** ppVertexData);
|
|
void WINAPI D3DDevice_EndIndexedVertices(__in D3DDevice *pDevice);
|
|
DWORD WINAPI D3DDevice_InsertFence(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_BlockOnFence(DWORD Fence);
|
|
BOOL WINAPI D3DDevice_IsFencePending(DWORD Fence);
|
|
void WINAPI D3DDevice_SetBlendState(__in D3DDevice* pDevice, DWORD RenderTargetIndex, D3DBLENDSTATE BlendState);
|
|
void WINAPI D3DDevice_GetBlendState(__in D3DDevice* pDevice, DWORD RenderTargetIndex, __out D3DBLENDSTATE* pBlendState);
|
|
void WINAPI D3DDevice_SetVertexFetchConstant(__in D3DDevice* pDevice, UINT VertexFetchRegister, __in D3DVertexBuffer* pVertexBuffer, UINT Offset);
|
|
void WINAPI D3DDevice_SetTextureFetchConstant(__in D3DDevice* pDevice, UINT TextureFetchRegister, __in D3DBaseTexture* pTexture);
|
|
float WINAPI D3DDevice_GetCounter(__in D3DDevice* pDevice, D3DCOUNTER CounterID);
|
|
void WINAPI D3DDevice_SetSafeLevel(__in D3DDevice* pDevice, DWORD Flags, DWORD Level);
|
|
void WINAPI D3DDevice_GetSafeLevel(__in D3DDevice* pDevice, DWORD* pFlags, __out DWORD* pLevel);
|
|
void WINAPI D3DDevice_SetHangCallback(__in D3DDevice* pDevice, D3DHANGCALLBACK pCallback);
|
|
void WINAPI D3DDevice_BeginConditionalSurvey(__in D3DDevice* pDevice, DWORD Identifier, DWORD Flags);
|
|
void WINAPI D3DDevice_EndConditionalSurvey(__in D3DDevice* pDevice, DWORD Flags);
|
|
void WINAPI D3DDevice_BeginConditionalRendering(__in D3DDevice* pDevice, DWORD Identifier);
|
|
void WINAPI D3DDevice_EndConditionalRendering(__in D3DDevice* pDevice);
|
|
HRESULT WINAPI D3DDevice_PersistDisplay(__in D3DDevice* pDevice, __in D3DTexture* pFrontBuffer, __in_opt CONST D3DVIDEO_SCALER_PARAMETERS* pParameters);
|
|
HRESULT WINAPI D3DDevice_GetPersistedTexture(__in D3DDevice* pDevice, __deref_out D3DTexture** pFrontBuffer);
|
|
void WINAPI D3DDevice_Suspend(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_Resume(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_EnablePerfCounters(__in D3DDevice* pDevice, BOOL Enable);
|
|
void WINAPI D3DDevice_SetPerfCounterEvents(__in D3DDevice* pDevice, __in CONST D3DPERFCOUNTER_EVENTS* pEvents, DWORD Flags);
|
|
void WINAPI D3DDevice_QueryPerfCounters(__in D3DDevice* pDevice, __in D3DPerfCounters* pCounters, DWORD Flags);
|
|
DWORD WINAPI D3DDevice_GetNumPasses(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_SetShaderInstructionAllocation(__in D3DDevice* pDevice, DWORD Flags, DWORD VertexShaderBase, DWORD PixelShaderBase);
|
|
void WINAPI D3DDevice_SetShaderGPRAllocation(__in D3DDevice* pDevice, DWORD Flags, DWORD VertexShaderCount, DWORD PixelShaderCount);
|
|
void WINAPI D3DDevice_GetShaderGPRAllocation(__in D3DDevice* pDevice, __out DWORD* pFlags, __out DWORD* pVertexShaderCount, __out DWORD* pPixelShaderCount);
|
|
void WINAPI D3DDevice_SetScreenExtentQueryMode(__in D3DDevice* pDevice, D3DSCREENEXTENTQUERYMODE Mode);
|
|
void WINAPI D3DDevice_GetScreenExtentQueryMode(__in D3DDevice* pDevice, __out D3DSCREENEXTENTQUERYMODE* pMode);
|
|
void WINAPI D3DDevice_BeginShaderConstantF1_ParameterCheck(__in D3DDevice *pDevice, BOOL PixelShader, UINT StartRegister, DWORD Vector4fCount);
|
|
void WINAPI D3DDevice_EndShaderConstantF1_ParameterCheck(__in D3DDevice *pDevice);
|
|
HRESULT WINAPI D3DDevice_BeginShaderConstantF4(__in D3DDevice *pDevice, BOOL PixelShader, UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppCachedConstantData, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppWriteCombinedConstantData, DWORD Vector4fCount);
|
|
void WINAPI D3DDevice_EndShaderConstantF4_ParameterCheck(__in D3DDevice *pDevice);
|
|
DWORD WINAPI D3DDevice_GetCurrentFence();
|
|
void WINAPI D3DDevice_InvalidateGpuCache(__in D3DDevice* pDevice, __in_bcount(Size) void* pBaseAddress, DWORD Size, DWORD Flags);
|
|
void WINAPI D3DDevice_InvalidateResourceGpuCache(__in D3DDevice* pDevice, __in D3DResource* pResource, DWORD Flags);
|
|
void WINAPI D3DDevice_FlushHiZStencil(__in D3DDevice* pDevice, D3DFHZS_FLUSHTYPE FlushType);
|
|
void WINAPI D3DDevice_UnsetAll(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetDeviceState(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_SetBlockCallback(__in D3DDevice* pDevice, DWORD Flags, __in_opt D3DBLOCKCALLBACK pCallback);
|
|
void WINAPI D3DDevice_SetSurfaces(__in D3DDevice* pDevice, __in CONST D3DSURFACES* pSurfaces, DWORD Flags);
|
|
void WINAPI D3DDevice_BeginCommandBuffer(__in D3DDevice* pDevice, __in D3DCommandBuffer* pCommandBuffer, DWORD Flags, __in_opt CONST D3DTAGCOLLECTION* pInheritTags, __in_opt CONST D3DTAGCOLLECTION* pPersistTags, __in_opt CONST D3DRECT* pTilingRects, DWORD TileCount);
|
|
HRESULT WINAPI D3DDevice_EndCommandBuffer(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_RunCommandBuffer(__in D3DDevice* pDevice, __in D3DCommandBuffer* pD3dCommandBuffer, DWORD PredicationSelect);
|
|
HRESULT WINAPI D3DDevice_InsertAsyncCommandBufferCall(__in D3DDevice* pDevice, __in D3DAsyncCommandBufferCall* pAsyncCommandBufferCall, DWORD PredicationSelect, DWORD Flags);
|
|
void WINAPI D3DDevice_SetCommandBufferPredication(__in D3DDevice* pDevice, DWORD TilePredication, DWORD RunPredication);
|
|
DWORD WINAPI D3DDevice_InsertMarker(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_Nop(__in D3DDevice* pDevice, DWORD Count);
|
|
void WINAPI D3DDevice_QuerySwapStatus(__in D3DDevice* pDevice, __out D3DSWAP_STATUS* pSwapStatus);
|
|
DWORD WINAPI D3DDevice_PixBeginNamedEvent(__in D3DDevice *pDevice, DWORD Color, __in_z CONST char *szName, va_list Arglist);
|
|
DWORD WINAPI D3DDevice_PixEndNamedEvent(__in D3DDevice *pDevice);
|
|
void WINAPI D3DDevice_PixSetMarker(__in D3DDevice *pDevice, DWORD Color, __in_z CONST char *szName, va_list Arglist);
|
|
void WINAPI D3DDevice_PixIgnoreTexture(__in D3DDevice* pDevice, __in D3DBaseTexture* pTexture);
|
|
void WINAPI D3DDevice_PixStopIgnoringTexture(__in D3DDevice* pDevice, __in D3DBaseTexture* pTexture);
|
|
void WINAPI D3DDevice_PixIgnoreMemoryRange(__in D3DDevice* pDevice, __in_bcount(Size) const void* pBaseAddress, DWORD Size);
|
|
void WINAPI D3DDevice_PixStopIgnoringMemoryRange(__in D3DDevice* pDevice, __in_bcount(Size) const void* pBaseAddress, DWORD Size);
|
|
HRESULT WINAPI D3DDevice_PixSetTextureName(__in D3DDevice* pDevice, __in D3DBaseTexture* pTexture, __in_z const char* pName);
|
|
void WINAPI D3DDevice_PixReportNewTexture(__in D3DDevice* pDevice, __in D3DBaseTexture* pTexture);
|
|
void WINAPI D3DDevice_PixReportDeletedTexture(__in D3DDevice* pDevice, __in D3DBaseTexture* pTexture, BOOL BaseDeleted, BOOL MipDeleted);
|
|
void WINAPI D3DDevice_PixReportMovedMemoryRange(__in D3DDevice* pDevice, __in_bcount(Size) const void* pDestinationAddress, __in_bcount(Size) const void* pSourceAddress, DWORD Size);
|
|
void WINAPI D3DDevice_PixReportFreedMemoryRange(__in D3DDevice* pDevice, __in_bcount(Size) const void* pAddress, DWORD Size);
|
|
|
|
void WINAPI D3DDevice_SetViewportF(__in D3DDevice *pDevice, __in CONST D3DVIEWPORTF9* pViewportF);
|
|
void WINAPI D3DDevice_GetViewportF(__in D3DDevice *pDevice, __out D3DVIEWPORTF9* pViewportF);
|
|
HANDLE WINAPI D3DDevice_BeginVisibilitySurvey(__in D3DDevice* pDevice, DWORD Flags);
|
|
void WINAPI D3DDevice_EndVisibilitySurvey(__in D3DDevice* pDevice, HANDLE VisibilityHandle);
|
|
void WINAPI D3DDevice_SetSwapMode(__in D3DDevice* pDevice, BOOL Asynchronous);
|
|
D3DASYNCBLOCK WINAPI D3DDevice_InsertBlockOnAsyncResources(__in D3DDevice* pDevice, DWORD WriteCount, __in_ecount_opt(WriteCount) D3DResource* CONST* pWriteResourceList, DWORD ReadCount, __in_ecount_opt(ReadCount) D3DResource* CONST* pReadResourceList, DWORD Flags);
|
|
void WINAPI D3DDevice_SignalAsyncResources(__in D3DDevice* pDevice, D3DASYNCBLOCK AsyncBlock);
|
|
D3DAsyncCommandBufferCall* WINAPI D3DDevice_CreateAsyncCommandBufferCall(__in D3DDevice* pDevice, __in_opt D3DTAGCOLLECTION* pInheritTags, __in_opt D3DTAGCOLLECTION* pPersistTags, DWORD NumSegments, DWORD Flags);
|
|
|
|
void WINAPI D3DDevice_SetRenderState_CullMode(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_FillMode(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_AlphaTestEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_AlphaBlendEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_BlendOp(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_SrcBlend(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_DestBlend(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_BlendOpAlpha(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_SrcBlendAlpha(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_DestBlendAlpha(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_SeparateAlphaBlendEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_AlphaRef(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_AlphaFunc(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_BlendFactor(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_ZEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_ZWriteEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_ZFunc(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_StencilEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_TwoSidedStencilMode(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_StencilFunc(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_StencilFail(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_StencilZFail(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_StencilPass(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_CCWStencilFunc(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_CCWStencilFail(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_CCWStencilZFail(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_CCWStencilPass(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_StencilRef(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_StencilMask(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_StencilWriteMask(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_CCWStencilRef(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_CCWStencilMask(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_CCWStencilWriteMask(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_ClipPlaneEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_ScissorTestEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_SlopeScaleDepthBias(__in D3DDevice* pDevice, DWORD FloatAsDword);
|
|
void WINAPI D3DDevice_SetRenderState_DepthBias(__in D3DDevice* pDevice, DWORD FloatAsDword);
|
|
void WINAPI D3DDevice_SetRenderState_MultiSampleAntiAlias(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_MultiSampleMask(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_ColorWriteEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_ColorWriteEnable1(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_ColorWriteEnable2(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_ColorWriteEnable3(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_PointSpriteEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_PointSize(__in D3DDevice* pDevice, DWORD FloatAsDword);
|
|
void WINAPI D3DDevice_SetRenderState_PointSizeMin(__in D3DDevice* pDevice, DWORD FloatAsDword);
|
|
void WINAPI D3DDevice_SetRenderState_PointSizeMax(__in D3DDevice* pDevice, DWORD FloatAsDword);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap0(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap1(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap2(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap3(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap4(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap5(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap6(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap7(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap8(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap9(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap10(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap11(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap12(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap13(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap14(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Wrap15(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_ViewportEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_HighPrecisionBlendEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_HighPrecisionBlendEnable1(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_HighPrecisionBlendEnable2(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_HighPrecisionBlendEnable3(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_MinTessellationLevel(__in D3DDevice* pDevice, DWORD FloatAsDword);
|
|
void WINAPI D3DDevice_SetRenderState_MaxTessellationLevel(__in D3DDevice* pDevice, DWORD FloatAsDword);
|
|
void WINAPI D3DDevice_SetRenderState_TessellationMode(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_HalfPixelOffset(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_PrimitiveResetEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_PrimitiveResetIndex(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_AlphaToMaskEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_AlphaToMaskOffsets(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_GuardBand_X(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_GuardBand_Y(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_DiscardBand_X(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_DiscardBand_Y(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_HiStencilEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_HiStencilWriteEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_HiStencilFunc(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_HiStencilRef(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_PresentInterval(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_PresentImmediateThreshold(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_HiZEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_HiZWriteEnable(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_LastPixel(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_LineWidth(__in D3DDevice* pDevice, DWORD Value);
|
|
void WINAPI D3DDevice_SetRenderState_Buffer2Frames(__in D3DDevice* pDevice, DWORD Value);
|
|
|
|
DWORD WINAPI D3DDevice_GetRenderState_CullMode(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_FillMode(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_AlphaTestEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_AlphaBlendEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_BlendOp(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_SrcBlend(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_DestBlend(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_BlendOpAlpha(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_SrcBlendAlpha(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_DestBlendAlpha(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_SeparateAlphaBlendEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_AlphaRef(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_AlphaFunc(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_BlendFactor(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_ZEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_ZWriteEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_ZFunc(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_StencilEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_TwoSidedStencilMode(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_StencilFunc(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_StencilFail(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_StencilZFail(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_StencilPass(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_CCWStencilFunc(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_CCWStencilFail(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_CCWStencilZFail(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_CCWStencilPass(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_StencilRef(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_StencilMask(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_StencilWriteMask(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_CCWStencilRef(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_CCWStencilMask(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_CCWStencilWriteMask(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_ClipPlaneEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_ScissorTestEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_SlopeScaleDepthBias(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_DepthBias(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_MultiSampleAntiAlias(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_MultiSampleMask(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_ColorWriteEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_ColorWriteEnable1(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_ColorWriteEnable2(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_ColorWriteEnable3(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_PointSpriteEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_PointSize(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_PointSizeMin(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_PointSizeMax(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap0(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap1(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap2(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap3(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap4(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap5(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap6(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap7(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap8(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap9(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap10(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap11(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap12(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap13(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap14(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Wrap15(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_ViewportEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_HighPrecisionBlendEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_HighPrecisionBlendEnable1(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_HighPrecisionBlendEnable2(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_HighPrecisionBlendEnable3(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_MinTessellationLevel(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_MaxTessellationLevel(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_TessellationMode(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_HalfPixelOffset(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_PrimitiveResetEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_PrimitiveResetIndex(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_AlphaToMaskEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_AlphaToMaskOffsets(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_GuardBand_X(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_GuardBand_Y(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_DiscardBand_X(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_DiscardBand_Y(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_HiStencilEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_HiStencilWriteEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_HiStencilFunc(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_HiStencilRef(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_PresentInterval(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_PresentImmediateThreshold(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_HiZEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_HiZWriteEnable(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_LastPixel(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_LineWidth(__in D3DDevice* pDevice);
|
|
DWORD WINAPI D3DDevice_GetRenderState_Buffer2Frames(__in D3DDevice* pDevice);
|
|
|
|
void WINAPI D3DDevice_SetSamplerState_MinFilter(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_MinFilterZ(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_MagFilter(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_MagFilterZ(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_MipFilter(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_SeparateZFilterEnable(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_MaxAnisotropy(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_AnisotropyBias(__in D3DDevice* pDevice, DWORD Sampler, DWORD FloatAsDword);
|
|
void WINAPI D3DDevice_SetSamplerState_MipMapLodBias(__in D3DDevice* pDevice, DWORD Sampler, DWORD FloatAsDword);
|
|
void WINAPI D3DDevice_SetSamplerState_MaxMipLevel(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_MinMipLevel(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_BorderColor(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_AddressU(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_AddressV(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_AddressW(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_TrilinearThreshold(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_HGradientExpBias(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_VGradientExpBias(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_WhiteBorderColorW(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
void WINAPI D3DDevice_SetSamplerState_PointBorderEnable(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value);
|
|
|
|
DWORD WINAPI D3DDevice_GetSamplerState_MinFilter(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_MinFilterZ(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_MagFilter(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_MagFilterZ(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_MipFilter(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_SeparateZFilterEnable(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_MaxAnisotropy(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_AnisotropyBias(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_MipMapLodBias(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_MaxMipLevel(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_MinMipLevel(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_BorderColor(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_AddressU(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_AddressV(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_AddressW(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_TrilinearThreshold(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_HGradientExpBias(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_VGradientExpBias(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_WhiteBorderColorW(__in D3DDevice* pDevice, DWORD Sampler);
|
|
DWORD WINAPI D3DDevice_GetSamplerState_PointBorderEnable(__in D3DDevice* pDevice, DWORD Sampler);
|
|
|
|
__out D3DVECTOR4* WINAPI D3DDevice_GpuBeginShaderConstantF4(__in D3DDevice* pDevice, BOOL PixelShader, UINT StartRegister, DWORD Vector4fCount);
|
|
|
|
void WINAPI D3DDevice_GpuOwn_ParameterCheck(__in D3DDevice *pDevice, DWORD Index, UINT64 Mask);
|
|
void WINAPI D3DDevice_GpuDisown_ParameterCheck(__in D3DDevice *pDevice, DWORD Index, UINT64 Mask);
|
|
void WINAPI D3DDevice_GpuDisownAll(__in D3DDevice *pDevice);
|
|
void WINAPI D3DDevice_GpuEndShaderConstantF4_ParameterCheck(__in D3DDevice* pDevice);
|
|
void WINAPI D3DDevice_GpuLoadShaderConstantF4(__in D3DDevice* pDevice, BOOL PixelShader, UINT StartRegister, DWORD Vector4fCount, __in D3DConstantBuffer* pConstantBuffer, DWORD OffsetInVectors);
|
|
void WINAPI D3DDevice_GpuLoadShaderConstantF4Pointer(__in D3DDevice* pDevice, BOOL PixelShader, UINT StartRegister, __in_bcount(4*sizeof(FLOAT)*Vector4fCount) CONST void* pConstantData, DWORD Vector4fCount);
|
|
void WINAPI D3DDevice_GpuLoadShadersFast(__in D3DDevice* pDevice, __in D3DVertexShader* pVertexShader, __in_opt D3DPixelShader* pPixelShader, __in_opt CONST GPUFLOW_CONSTANTS* pFlowConstants, DWORD Flags);
|
|
void WINAPI D3DDevice_GpuSetVertexFetchConstant(__in D3DDevice* pDevice, DWORD VertexFetchRegister, __in_opt D3DVertexBuffer* pVertexBuffer0, DWORD OffsetInBytes0, __in_opt D3DVertexBuffer* pVertexBuffer1, DWORD OffsetInBytes1, __in_opt D3DVertexBuffer* pVertexBuffer2, DWORD OffsetInBytes2);
|
|
void WINAPI D3DDevice_GpuSetTextureFetchConstant(__in D3DDevice* pDevice, DWORD TextureFetchRegister, __in D3DBaseTexture* pTexture);
|
|
void WINAPI D3DDevice_GpuSetColorMask(__in D3DDevice* pDevice, DWORD ColorMask);
|
|
void WINAPI D3DDevice_GpuSetBlendFactor(__in D3DDevice* pDevice, float r, float g, float b, float a);
|
|
void WINAPI D3DDevice_GpuSetAlphaRef(__in D3DDevice* pDevice, float Ref);
|
|
void WINAPI D3DDevice_GpuSetBlendControl(__in D3DDevice* pDevice, DWORD RenderTargetIndex, DWORD BlendControl);
|
|
void WINAPI D3DDevice_GpuSetColorControl(__in D3DDevice* pDevice, DWORD ColorControl);
|
|
|
|
D3DINLINE void WINAPI D3DDevice_GpuLoadShaders(__in D3DDevice* pDevice, __in D3DVertexShader* pVertexShader, __in_opt D3DPixelShader* pPixelShader, __in_opt CONST GPUFLOW_CONSTANTS* pFlowConstants)
|
|
{
|
|
D3DDevice_GpuLoadShadersFast(pDevice, pVertexShader, pPixelShader, pFlowConstants, 0);
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerState_AddressU_Inline(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value)
|
|
{
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].ClampX = (GPUCLAMP)Value;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerState_AddressV_Inline(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value)
|
|
{
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].ClampY = (GPUCLAMP)Value;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerState_AddressW_Inline(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value)
|
|
{
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].ClampZ = (GPUCLAMP)Value;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerState_MipFilter_Inline(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value)
|
|
{
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].MipFilter = Value;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerState_BorderColor_Inline(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value)
|
|
{
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].BorderColor = (Value == 0) ? GPUBORDERCOLOR_ABGR_BLACK : GPUBORDERCOLOR_ABGR_WHITE;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerState_TrilinearThreshold_Inline(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value)
|
|
{
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].TriClamp = (GPUTRICLAMP)Value;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerState_HGradientExpBias_Inline(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value)
|
|
{
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].GradExpAdjustH = (INT) Value;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerState_VGradientExpBias_Inline(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value)
|
|
{
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].GradExpAdjustV = (INT) Value;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerState_WhiteBorderColorW_Inline(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value)
|
|
{
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].ForceBCWToMax = Value;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerState_PointBorderEnable_Inline(__in D3DDevice* pDevice, DWORD Sampler, DWORD Value)
|
|
{
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].ClampPolicy = (GPUCLAMPPOLICY)!Value;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetStreamSource_Inline(__in D3DDevice* pDevice, UINT StreamNumber, __in_opt D3DVertexBuffer *pStreamData, UINT OffsetInBytes, UINT Stride)
|
|
{
|
|
// The GPU has 96 vertex fetch constants and the hardware requires that they
|
|
// be set in groups of 3. This API has no notion of that requirement, so
|
|
// we defer actually setting the fetch constants to the hardware until
|
|
// the next 'Draw' time. What we do here is calculate the mask which will
|
|
// be ORed into D3DDevice::m_Pending[2] to indicate that the corresponding
|
|
// fetch constant needs to be set.
|
|
//
|
|
// When this API is called with a constant value for 'StreamNumber', all of
|
|
// this mask calculation code collapses to a single 'li' instruction. When
|
|
// passed a variable, we have to do more run-time work which includes
|
|
// dividing by 3 (which we approximate with a fixed-point multiply since
|
|
// that's faster).
|
|
DWORD vertexFetchConstant = GPU_CONVERT_D3D_TO_HARDWARE_VERTEXFETCHCONSTANT(StreamNumber);
|
|
DWORD fetchConstant = (vertexFetchConstant * (65536/3 + 1)) >> 16;
|
|
UINT64 pendingMask3 = D3DTAG_MASKENCODE(D3DTAG_START(D3DTAG_FETCHCONSTANTS) + fetchConstant, D3DTAG_START(D3DTAG_FETCHCONSTANTS) + fetchConstant);
|
|
|
|
D3DDevice_SetStreamSource(pDevice, StreamNumber, pStreamData, OffsetInBytes, Stride, pendingMask3);
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetTexture_Inline(__in D3DDevice* pDevice, DWORD Sampler, __in_opt D3DBaseTexture *pTexture)
|
|
{
|
|
// As with D3DDevice_SetStreamSource_Inline above, we precompute the
|
|
// pending mask here to get a win when passed in a constant 'Sampler'
|
|
// value. The win here isn't as great, but we do avoid a shift-by-
|
|
// variable when given a constant which is a win because all such
|
|
// operations are handled in microcode by the CPU.
|
|
DWORD fetchConstant = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
UINT64 pendingMask3 = D3DTAG_MASKENCODE(D3DTAG_START(D3DTAG_FETCHCONSTANTS) + fetchConstant, D3DTAG_START(D3DTAG_FETCHCONSTANTS) + fetchConstant);
|
|
|
|
D3DDevice_SetTexture(pDevice, Sampler, pTexture, pendingMask3);
|
|
}
|
|
|
|
// When SetRenderState or SetSamplerState are called with a non-constant
|
|
// state type we indirect through a function-table which hangs off the device.
|
|
//
|
|
// In order to save a shift instruction we've pre-scaled the constants
|
|
// by 4 (the stride of the table) and do an ugly bit of casting.
|
|
|
|
D3DINLINE void D3DDevice_SetRenderState(__in D3DDevice* pDevice, D3DRENDERSTATETYPE State, DWORD Value)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_SetRenderState_ParameterCheck(pDevice, State, Value);
|
|
#endif
|
|
|
|
// Note that D3DISINTCONST() always evaluates to a constant:
|
|
|
|
if (!D3DISINTCONST(State))
|
|
{
|
|
// When 'State' is passed in using a non-constant we avoid horrendous
|
|
// code bloat by calling through the jump table:
|
|
|
|
// Setting the state uses a function pointer table that assumes
|
|
// the pointers are 4 bytes in size. The pointer arithemetic for
|
|
// State*(sizeof(ULONG_PTR)/sizeof(DWORD)) uses platform specific
|
|
// ULONG_PTR type, which is the size of pointer, that when compiled
|
|
// is either compiled away (when sizeof(ULONG_PTR)/sizeof(DWORD) == 1)
|
|
// or becomes the specific multiple of the byte size for a pointer
|
|
// on the specific platform to ensure proper incrementation of the
|
|
// SetState pointer.
|
|
|
|
(*(D3DSETRENDERSTATECALL*)(((BYTE*) &pDevice->m_SetRenderStateCall[0] + State*(sizeof(ULONG_PTR)/sizeof(DWORD)))))(pDevice, Value);
|
|
}
|
|
else
|
|
{
|
|
// When 'State' is passed in using a constant the optimizer can
|
|
// eliminate this entire switch statement:
|
|
|
|
switch (State)
|
|
{
|
|
case D3DRS_ZENABLE: D3DDevice_SetRenderState_ZEnable(pDevice, Value); break;
|
|
case D3DRS_ZFUNC: D3DDevice_SetRenderState_ZFunc(pDevice, Value); break;
|
|
case D3DRS_ZWRITEENABLE: D3DDevice_SetRenderState_ZWriteEnable(pDevice, Value); break;
|
|
case D3DRS_FILLMODE: D3DDevice_SetRenderState_FillMode(pDevice, Value); break;
|
|
case D3DRS_CULLMODE: D3DDevice_SetRenderState_CullMode(pDevice, Value); break;
|
|
case D3DRS_ALPHABLENDENABLE: D3DDevice_SetRenderState_AlphaBlendEnable(pDevice, Value); break;
|
|
case D3DRS_SEPARATEALPHABLENDENABLE: D3DDevice_SetRenderState_SeparateAlphaBlendEnable(pDevice, Value); break;
|
|
case D3DRS_BLENDFACTOR: D3DDevice_SetRenderState_BlendFactor(pDevice, Value); break;
|
|
case D3DRS_SRCBLEND: D3DDevice_SetRenderState_SrcBlend(pDevice, Value); break;
|
|
case D3DRS_DESTBLEND: D3DDevice_SetRenderState_DestBlend(pDevice, Value); break;
|
|
case D3DRS_BLENDOP: D3DDevice_SetRenderState_BlendOp(pDevice, Value); break;
|
|
case D3DRS_SRCBLENDALPHA: D3DDevice_SetRenderState_SrcBlendAlpha(pDevice, Value); break;
|
|
case D3DRS_DESTBLENDALPHA: D3DDevice_SetRenderState_DestBlendAlpha(pDevice, Value); break;
|
|
case D3DRS_BLENDOPALPHA: D3DDevice_SetRenderState_BlendOpAlpha(pDevice, Value); break;
|
|
case D3DRS_ALPHATESTENABLE: D3DDevice_SetRenderState_AlphaTestEnable(pDevice, Value); break;
|
|
case D3DRS_ALPHAREF: D3DDevice_SetRenderState_AlphaRef(pDevice, Value); break;
|
|
case D3DRS_ALPHAFUNC: D3DDevice_SetRenderState_AlphaFunc(pDevice, Value); break;
|
|
case D3DRS_STENCILENABLE: D3DDevice_SetRenderState_StencilEnable(pDevice, Value); break;
|
|
case D3DRS_TWOSIDEDSTENCILMODE: D3DDevice_SetRenderState_TwoSidedStencilMode(pDevice, Value); break;
|
|
case D3DRS_STENCILFAIL: D3DDevice_SetRenderState_StencilFail(pDevice, Value); break;
|
|
case D3DRS_STENCILZFAIL: D3DDevice_SetRenderState_StencilZFail(pDevice, Value); break;
|
|
case D3DRS_STENCILPASS: D3DDevice_SetRenderState_StencilPass(pDevice, Value); break;
|
|
case D3DRS_STENCILFUNC: D3DDevice_SetRenderState_StencilFunc(pDevice, Value); break;
|
|
case D3DRS_STENCILREF: D3DDevice_SetRenderState_StencilRef(pDevice, Value); break;
|
|
case D3DRS_STENCILMASK: D3DDevice_SetRenderState_StencilMask(pDevice, Value); break;
|
|
case D3DRS_STENCILWRITEMASK: D3DDevice_SetRenderState_StencilWriteMask(pDevice, Value); break;
|
|
case D3DRS_CCW_STENCILFAIL: D3DDevice_SetRenderState_CCWStencilFail(pDevice, Value); break;
|
|
case D3DRS_CCW_STENCILZFAIL: D3DDevice_SetRenderState_CCWStencilZFail(pDevice, Value); break;
|
|
case D3DRS_CCW_STENCILPASS: D3DDevice_SetRenderState_CCWStencilPass(pDevice, Value); break;
|
|
case D3DRS_CCW_STENCILFUNC: D3DDevice_SetRenderState_CCWStencilFunc(pDevice, Value); break;
|
|
case D3DRS_CCW_STENCILREF: D3DDevice_SetRenderState_CCWStencilRef(pDevice, Value); break;
|
|
case D3DRS_CCW_STENCILMASK: D3DDevice_SetRenderState_CCWStencilMask(pDevice, Value); break;
|
|
case D3DRS_CCW_STENCILWRITEMASK: D3DDevice_SetRenderState_CCWStencilWriteMask(pDevice, Value); break;
|
|
case D3DRS_CLIPPLANEENABLE: D3DDevice_SetRenderState_ClipPlaneEnable(pDevice, Value); break;
|
|
case D3DRS_POINTSIZE: D3DDevice_SetRenderState_PointSize(pDevice, Value); break;
|
|
case D3DRS_POINTSIZE_MIN: D3DDevice_SetRenderState_PointSizeMin(pDevice, Value); break;
|
|
case D3DRS_POINTSPRITEENABLE: D3DDevice_SetRenderState_PointSpriteEnable(pDevice, Value); break;
|
|
case D3DRS_POINTSIZE_MAX: D3DDevice_SetRenderState_PointSizeMax(pDevice, Value); break;
|
|
case D3DRS_MULTISAMPLEANTIALIAS: D3DDevice_SetRenderState_MultiSampleAntiAlias(pDevice, Value); break;
|
|
case D3DRS_MULTISAMPLEMASK: D3DDevice_SetRenderState_MultiSampleMask(pDevice, Value); break;
|
|
case D3DRS_SCISSORTESTENABLE: D3DDevice_SetRenderState_ScissorTestEnable(pDevice, Value); break;
|
|
case D3DRS_SLOPESCALEDEPTHBIAS: D3DDevice_SetRenderState_SlopeScaleDepthBias(pDevice, Value); break;
|
|
case D3DRS_DEPTHBIAS: D3DDevice_SetRenderState_DepthBias(pDevice, Value); break;
|
|
case D3DRS_COLORWRITEENABLE: D3DDevice_SetRenderState_ColorWriteEnable(pDevice, Value); break;
|
|
case D3DRS_COLORWRITEENABLE1: D3DDevice_SetRenderState_ColorWriteEnable1(pDevice, Value); break;
|
|
case D3DRS_COLORWRITEENABLE2: D3DDevice_SetRenderState_ColorWriteEnable2(pDevice, Value); break;
|
|
case D3DRS_COLORWRITEENABLE3: D3DDevice_SetRenderState_ColorWriteEnable3(pDevice, Value); break;
|
|
case D3DRS_TESSELLATIONMODE: D3DDevice_SetRenderState_TessellationMode(pDevice, Value); break;
|
|
case D3DRS_MINTESSELLATIONLEVEL: D3DDevice_SetRenderState_MinTessellationLevel(pDevice, Value); break;
|
|
case D3DRS_MAXTESSELLATIONLEVEL: D3DDevice_SetRenderState_MaxTessellationLevel(pDevice, Value); break;
|
|
case D3DRS_WRAP0: D3DDevice_SetRenderState_Wrap0(pDevice, Value); break;
|
|
case D3DRS_WRAP1: D3DDevice_SetRenderState_Wrap1(pDevice, Value); break;
|
|
case D3DRS_WRAP2: D3DDevice_SetRenderState_Wrap2(pDevice, Value); break;
|
|
case D3DRS_WRAP3: D3DDevice_SetRenderState_Wrap3(pDevice, Value); break;
|
|
case D3DRS_WRAP4: D3DDevice_SetRenderState_Wrap4(pDevice, Value); break;
|
|
case D3DRS_WRAP5: D3DDevice_SetRenderState_Wrap5(pDevice, Value); break;
|
|
case D3DRS_WRAP6: D3DDevice_SetRenderState_Wrap6(pDevice, Value); break;
|
|
case D3DRS_WRAP7: D3DDevice_SetRenderState_Wrap7(pDevice, Value); break;
|
|
case D3DRS_WRAP8: D3DDevice_SetRenderState_Wrap8(pDevice, Value); break;
|
|
case D3DRS_WRAP9: D3DDevice_SetRenderState_Wrap9(pDevice, Value); break;
|
|
case D3DRS_WRAP10: D3DDevice_SetRenderState_Wrap10(pDevice, Value); break;
|
|
case D3DRS_WRAP11: D3DDevice_SetRenderState_Wrap11(pDevice, Value); break;
|
|
case D3DRS_WRAP12: D3DDevice_SetRenderState_Wrap12(pDevice, Value); break;
|
|
case D3DRS_WRAP13: D3DDevice_SetRenderState_Wrap13(pDevice, Value); break;
|
|
case D3DRS_WRAP14: D3DDevice_SetRenderState_Wrap14(pDevice, Value); break;
|
|
case D3DRS_WRAP15: D3DDevice_SetRenderState_Wrap15(pDevice, Value); break;
|
|
case D3DRS_VIEWPORTENABLE: D3DDevice_SetRenderState_ViewportEnable(pDevice, Value); break;
|
|
case D3DRS_HIGHPRECISIONBLENDENABLE: D3DDevice_SetRenderState_HighPrecisionBlendEnable(pDevice, Value); break;
|
|
case D3DRS_HIGHPRECISIONBLENDENABLE1: D3DDevice_SetRenderState_HighPrecisionBlendEnable1(pDevice, Value); break;
|
|
case D3DRS_HIGHPRECISIONBLENDENABLE2: D3DDevice_SetRenderState_HighPrecisionBlendEnable2(pDevice, Value); break;
|
|
case D3DRS_HIGHPRECISIONBLENDENABLE3: D3DDevice_SetRenderState_HighPrecisionBlendEnable3(pDevice, Value); break;
|
|
case D3DRS_HALFPIXELOFFSET: D3DDevice_SetRenderState_HalfPixelOffset(pDevice, Value); break;
|
|
case D3DRS_PRIMITIVERESETENABLE: D3DDevice_SetRenderState_PrimitiveResetEnable(pDevice, Value); break;
|
|
case D3DRS_PRIMITIVERESETINDEX: D3DDevice_SetRenderState_PrimitiveResetIndex(pDevice, Value); break;
|
|
case D3DRS_ALPHATOMASKENABLE: D3DDevice_SetRenderState_AlphaToMaskEnable(pDevice, Value); break;
|
|
case D3DRS_ALPHATOMASKOFFSETS: D3DDevice_SetRenderState_AlphaToMaskOffsets(pDevice, Value); break;
|
|
case D3DRS_GUARDBAND_X: D3DDevice_SetRenderState_GuardBand_X(pDevice, Value); break;
|
|
case D3DRS_GUARDBAND_Y: D3DDevice_SetRenderState_GuardBand_Y(pDevice, Value); break;
|
|
case D3DRS_DISCARDBAND_X: D3DDevice_SetRenderState_DiscardBand_X(pDevice, Value); break;
|
|
case D3DRS_DISCARDBAND_Y: D3DDevice_SetRenderState_DiscardBand_Y(pDevice, Value); break;
|
|
case D3DRS_HISTENCILENABLE: D3DDevice_SetRenderState_HiStencilEnable(pDevice, Value); break;
|
|
case D3DRS_HISTENCILWRITEENABLE: D3DDevice_SetRenderState_HiStencilWriteEnable(pDevice, Value); break;
|
|
case D3DRS_HISTENCILFUNC: D3DDevice_SetRenderState_HiStencilFunc(pDevice, Value); break;
|
|
case D3DRS_HISTENCILREF: D3DDevice_SetRenderState_HiStencilRef(pDevice, Value); break;
|
|
case D3DRS_PRESENTINTERVAL: D3DDevice_SetRenderState_PresentInterval(pDevice, Value); break;
|
|
case D3DRS_PRESENTIMMEDIATETHRESHOLD: D3DDevice_SetRenderState_PresentImmediateThreshold(pDevice, Value); break;
|
|
case D3DRS_HIZENABLE: D3DDevice_SetRenderState_HiZEnable(pDevice, Value); break;
|
|
case D3DRS_HIZWRITEENABLE: D3DDevice_SetRenderState_HiZWriteEnable(pDevice, Value); break;
|
|
case D3DRS_LASTPIXEL: D3DDevice_SetRenderState_LastPixel(pDevice, Value); break;
|
|
case D3DRS_LINEWIDTH: D3DDevice_SetRenderState_LineWidth(pDevice, Value); break;
|
|
case D3DRS_BUFFER2FRAMES: D3DDevice_SetRenderState_Buffer2Frames(pDevice, Value); break;
|
|
|
|
#if defined(_DEBUG)
|
|
default: __debugbreak();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
D3DINLINE void D3DDevice_GetRenderState(__in D3DDevice* pDevice, D3DRENDERSTATETYPE State, __out DWORD* pValue)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_GetRenderState_ParameterCheck(pDevice, State);
|
|
#endif
|
|
|
|
if (!D3DISINTCONST(State))
|
|
{
|
|
// Getting the state uses a function pointer table that assumes
|
|
// the pointers are 4 bytes in size. The pointer arithemetic for
|
|
// State*(sizeof(ULONG_PTR)/sizeof(DWORD)) uses platform specific
|
|
// ULONG_PTR type, which is the size of pointer, that when compiled
|
|
// is either compiled away (when sizeof(ULONG_PTR)/sizeof(DWORD) == 1)
|
|
// or becomes the specific multiple of the byte size for a pointer
|
|
// on the specific platform to ensure proper incrementation of the
|
|
// GetState pointer.
|
|
|
|
*pValue = (*(D3DGETRENDERSTATECALL*)(((BYTE*) &pDevice->m_GetRenderStateCall[0] + State*(sizeof(ULONG_PTR)/sizeof(DWORD)))))(pDevice);
|
|
}
|
|
else
|
|
{
|
|
switch (State)
|
|
{
|
|
case D3DRS_ZENABLE: *pValue = D3DDevice_GetRenderState_ZEnable(pDevice); break;
|
|
case D3DRS_ZFUNC: *pValue = D3DDevice_GetRenderState_ZFunc(pDevice); break;
|
|
case D3DRS_ZWRITEENABLE: *pValue = D3DDevice_GetRenderState_ZWriteEnable(pDevice); break;
|
|
case D3DRS_FILLMODE: *pValue = D3DDevice_GetRenderState_FillMode(pDevice); break;
|
|
case D3DRS_CULLMODE: *pValue = D3DDevice_GetRenderState_CullMode(pDevice); break;
|
|
case D3DRS_ALPHABLENDENABLE: *pValue = D3DDevice_GetRenderState_AlphaBlendEnable(pDevice); break;
|
|
case D3DRS_SEPARATEALPHABLENDENABLE: *pValue = D3DDevice_GetRenderState_SeparateAlphaBlendEnable(pDevice); break;
|
|
case D3DRS_BLENDFACTOR: *pValue = D3DDevice_GetRenderState_BlendFactor(pDevice); break;
|
|
case D3DRS_SRCBLEND: *pValue = D3DDevice_GetRenderState_SrcBlend(pDevice); break;
|
|
case D3DRS_DESTBLEND: *pValue = D3DDevice_GetRenderState_DestBlend(pDevice); break;
|
|
case D3DRS_BLENDOP: *pValue = D3DDevice_GetRenderState_BlendOp(pDevice); break;
|
|
case D3DRS_SRCBLENDALPHA: *pValue = D3DDevice_GetRenderState_SrcBlendAlpha(pDevice); break;
|
|
case D3DRS_DESTBLENDALPHA: *pValue = D3DDevice_GetRenderState_DestBlendAlpha(pDevice); break;
|
|
case D3DRS_BLENDOPALPHA: *pValue = D3DDevice_GetRenderState_BlendOpAlpha(pDevice); break;
|
|
case D3DRS_ALPHATESTENABLE: *pValue = D3DDevice_GetRenderState_AlphaTestEnable(pDevice); break;
|
|
case D3DRS_ALPHAREF: *pValue = D3DDevice_GetRenderState_AlphaRef(pDevice); break;
|
|
case D3DRS_ALPHAFUNC: *pValue = D3DDevice_GetRenderState_AlphaFunc(pDevice); break;
|
|
case D3DRS_STENCILENABLE: *pValue = D3DDevice_GetRenderState_StencilEnable(pDevice); break;
|
|
case D3DRS_TWOSIDEDSTENCILMODE: *pValue = D3DDevice_GetRenderState_TwoSidedStencilMode(pDevice); break;
|
|
case D3DRS_STENCILFAIL: *pValue = D3DDevice_GetRenderState_StencilFail(pDevice); break;
|
|
case D3DRS_STENCILZFAIL: *pValue = D3DDevice_GetRenderState_StencilZFail(pDevice); break;
|
|
case D3DRS_STENCILPASS: *pValue = D3DDevice_GetRenderState_StencilPass(pDevice); break;
|
|
case D3DRS_STENCILFUNC: *pValue = D3DDevice_GetRenderState_StencilFunc(pDevice); break;
|
|
case D3DRS_STENCILREF: *pValue = D3DDevice_GetRenderState_StencilRef(pDevice); break;
|
|
case D3DRS_STENCILMASK: *pValue = D3DDevice_GetRenderState_StencilMask(pDevice); break;
|
|
case D3DRS_STENCILWRITEMASK: *pValue = D3DDevice_GetRenderState_StencilWriteMask(pDevice); break;
|
|
case D3DRS_CCW_STENCILFAIL: *pValue = D3DDevice_GetRenderState_CCWStencilFail(pDevice); break;
|
|
case D3DRS_CCW_STENCILZFAIL: *pValue = D3DDevice_GetRenderState_CCWStencilZFail(pDevice); break;
|
|
case D3DRS_CCW_STENCILPASS: *pValue = D3DDevice_GetRenderState_CCWStencilPass(pDevice); break;
|
|
case D3DRS_CCW_STENCILFUNC: *pValue = D3DDevice_GetRenderState_CCWStencilFunc(pDevice); break;
|
|
case D3DRS_CCW_STENCILREF: *pValue = D3DDevice_GetRenderState_CCWStencilRef(pDevice); break;
|
|
case D3DRS_CCW_STENCILMASK: *pValue = D3DDevice_GetRenderState_CCWStencilMask(pDevice); break;
|
|
case D3DRS_CCW_STENCILWRITEMASK: *pValue = D3DDevice_GetRenderState_CCWStencilWriteMask(pDevice); break;
|
|
case D3DRS_CLIPPLANEENABLE: *pValue = D3DDevice_GetRenderState_ClipPlaneEnable(pDevice); break;
|
|
case D3DRS_POINTSIZE: *pValue = D3DDevice_GetRenderState_PointSize(pDevice); break;
|
|
case D3DRS_POINTSIZE_MIN: *pValue = D3DDevice_GetRenderState_PointSizeMin(pDevice); break;
|
|
case D3DRS_POINTSPRITEENABLE: *pValue = D3DDevice_GetRenderState_PointSpriteEnable(pDevice); break;
|
|
case D3DRS_POINTSIZE_MAX: *pValue = D3DDevice_GetRenderState_PointSizeMax(pDevice); break;
|
|
case D3DRS_MULTISAMPLEANTIALIAS: *pValue = D3DDevice_GetRenderState_MultiSampleAntiAlias(pDevice); break;
|
|
case D3DRS_MULTISAMPLEMASK: *pValue = D3DDevice_GetRenderState_MultiSampleMask(pDevice); break;
|
|
case D3DRS_SCISSORTESTENABLE: *pValue = D3DDevice_GetRenderState_ScissorTestEnable(pDevice); break;
|
|
case D3DRS_SLOPESCALEDEPTHBIAS: *pValue = D3DDevice_GetRenderState_SlopeScaleDepthBias(pDevice); break;
|
|
case D3DRS_DEPTHBIAS: *pValue = D3DDevice_GetRenderState_DepthBias(pDevice); break;
|
|
case D3DRS_COLORWRITEENABLE: *pValue = D3DDevice_GetRenderState_ColorWriteEnable(pDevice); break;
|
|
case D3DRS_COLORWRITEENABLE1: *pValue = D3DDevice_GetRenderState_ColorWriteEnable1(pDevice); break;
|
|
case D3DRS_COLORWRITEENABLE2: *pValue = D3DDevice_GetRenderState_ColorWriteEnable2(pDevice); break;
|
|
case D3DRS_COLORWRITEENABLE3: *pValue = D3DDevice_GetRenderState_ColorWriteEnable3(pDevice); break;
|
|
case D3DRS_TESSELLATIONMODE: *pValue = D3DDevice_GetRenderState_TessellationMode(pDevice); break;
|
|
case D3DRS_MINTESSELLATIONLEVEL: *pValue = D3DDevice_GetRenderState_MinTessellationLevel(pDevice); break;
|
|
case D3DRS_MAXTESSELLATIONLEVEL: *pValue = D3DDevice_GetRenderState_MaxTessellationLevel(pDevice); break;
|
|
case D3DRS_WRAP0: *pValue = D3DDevice_GetRenderState_Wrap0(pDevice); break;
|
|
case D3DRS_WRAP1: *pValue = D3DDevice_GetRenderState_Wrap1(pDevice); break;
|
|
case D3DRS_WRAP2: *pValue = D3DDevice_GetRenderState_Wrap2(pDevice); break;
|
|
case D3DRS_WRAP3: *pValue = D3DDevice_GetRenderState_Wrap3(pDevice); break;
|
|
case D3DRS_WRAP4: *pValue = D3DDevice_GetRenderState_Wrap4(pDevice); break;
|
|
case D3DRS_WRAP5: *pValue = D3DDevice_GetRenderState_Wrap5(pDevice); break;
|
|
case D3DRS_WRAP6: *pValue = D3DDevice_GetRenderState_Wrap6(pDevice); break;
|
|
case D3DRS_WRAP7: *pValue = D3DDevice_GetRenderState_Wrap7(pDevice); break;
|
|
case D3DRS_WRAP8: *pValue = D3DDevice_GetRenderState_Wrap8(pDevice); break;
|
|
case D3DRS_WRAP9: *pValue = D3DDevice_GetRenderState_Wrap9(pDevice); break;
|
|
case D3DRS_WRAP10: *pValue = D3DDevice_GetRenderState_Wrap10(pDevice); break;
|
|
case D3DRS_WRAP11: *pValue = D3DDevice_GetRenderState_Wrap11(pDevice); break;
|
|
case D3DRS_WRAP12: *pValue = D3DDevice_GetRenderState_Wrap12(pDevice); break;
|
|
case D3DRS_WRAP13: *pValue = D3DDevice_GetRenderState_Wrap13(pDevice); break;
|
|
case D3DRS_WRAP14: *pValue = D3DDevice_GetRenderState_Wrap14(pDevice); break;
|
|
case D3DRS_WRAP15: *pValue = D3DDevice_GetRenderState_Wrap15(pDevice); break;
|
|
case D3DRS_VIEWPORTENABLE: *pValue = D3DDevice_GetRenderState_ViewportEnable(pDevice); break;
|
|
case D3DRS_HIGHPRECISIONBLENDENABLE: *pValue = D3DDevice_GetRenderState_HighPrecisionBlendEnable(pDevice); break;
|
|
case D3DRS_HIGHPRECISIONBLENDENABLE1: *pValue = D3DDevice_GetRenderState_HighPrecisionBlendEnable1(pDevice); break;
|
|
case D3DRS_HIGHPRECISIONBLENDENABLE2: *pValue = D3DDevice_GetRenderState_HighPrecisionBlendEnable2(pDevice); break;
|
|
case D3DRS_HIGHPRECISIONBLENDENABLE3: *pValue = D3DDevice_GetRenderState_HighPrecisionBlendEnable3(pDevice); break;
|
|
case D3DRS_HALFPIXELOFFSET: *pValue = D3DDevice_GetRenderState_HalfPixelOffset(pDevice); break;
|
|
case D3DRS_PRIMITIVERESETENABLE: *pValue = D3DDevice_GetRenderState_PrimitiveResetEnable(pDevice); break;
|
|
case D3DRS_PRIMITIVERESETINDEX: *pValue = D3DDevice_GetRenderState_PrimitiveResetIndex(pDevice); break;
|
|
case D3DRS_ALPHATOMASKENABLE: *pValue = D3DDevice_GetRenderState_AlphaToMaskEnable(pDevice); break;
|
|
case D3DRS_ALPHATOMASKOFFSETS: *pValue = D3DDevice_GetRenderState_AlphaToMaskOffsets(pDevice); break;
|
|
case D3DRS_GUARDBAND_X: *pValue = D3DDevice_GetRenderState_GuardBand_X(pDevice); break;
|
|
case D3DRS_GUARDBAND_Y: *pValue = D3DDevice_GetRenderState_GuardBand_Y(pDevice); break;
|
|
case D3DRS_DISCARDBAND_X: *pValue = D3DDevice_GetRenderState_DiscardBand_X(pDevice); break;
|
|
case D3DRS_DISCARDBAND_Y: *pValue = D3DDevice_GetRenderState_DiscardBand_Y(pDevice); break;
|
|
case D3DRS_HISTENCILENABLE: *pValue = D3DDevice_GetRenderState_HiStencilEnable(pDevice); break;
|
|
case D3DRS_HISTENCILWRITEENABLE: *pValue = D3DDevice_GetRenderState_HiStencilWriteEnable(pDevice); break;
|
|
case D3DRS_HISTENCILFUNC: *pValue = D3DDevice_GetRenderState_HiStencilFunc(pDevice); break;
|
|
case D3DRS_HISTENCILREF: *pValue = D3DDevice_GetRenderState_HiStencilRef(pDevice); break;
|
|
case D3DRS_PRESENTINTERVAL: *pValue = D3DDevice_GetRenderState_PresentInterval(pDevice); break;
|
|
case D3DRS_PRESENTIMMEDIATETHRESHOLD: *pValue = D3DDevice_GetRenderState_PresentImmediateThreshold(pDevice); break;
|
|
case D3DRS_HIZENABLE: *pValue = D3DDevice_GetRenderState_HiZEnable(pDevice); break;
|
|
case D3DRS_HIZWRITEENABLE: *pValue = D3DDevice_GetRenderState_HiZWriteEnable(pDevice); break;
|
|
case D3DRS_LASTPIXEL: *pValue = D3DDevice_GetRenderState_LastPixel(pDevice); break;
|
|
case D3DRS_LINEWIDTH: *pValue = D3DDevice_GetRenderState_LineWidth(pDevice); break;
|
|
case D3DRS_BUFFER2FRAMES: *pValue = D3DDevice_GetRenderState_Buffer2Frames(pDevice); break;
|
|
|
|
#if defined(_DEBUG)
|
|
default: __debugbreak();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
D3DINLINE void D3DDevice_SetSamplerState(__in D3DDevice* pDevice, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, Type, Value);
|
|
#endif
|
|
|
|
// Note that D3DISINTCONST() always evaluates to a constant:
|
|
|
|
if (!D3DISINTCONST(Type))
|
|
{
|
|
// When 'Type' is passed in using a non-constant we avoid horrendous
|
|
// code bloat by calling through the jump table:
|
|
|
|
// Setting the state uses a function pointer table that assumes
|
|
// the pointers are 4 bytes in size. The pointer arithemetic for
|
|
// Type*(sizeof(ULONG_PTR)/sizeof(DWORD)) uses platform specific
|
|
// ULONG_PTR type, which is the size of pointer, that when compiled
|
|
// is either compiled away (when sizeof(ULONG_PTR)/sizeof(DWORD) == 1)
|
|
// or becomes the specific multiple of the byte size for a pointer
|
|
// on the specific platform to ensure proper incrementation of the
|
|
// SetState pointer.
|
|
|
|
(*(D3DSETSAMPLERSTATECALL*)(((BYTE*) &pDevice->m_SetSamplerStateCall[0] + Type*(sizeof(ULONG_PTR)/sizeof(DWORD)))))(pDevice, Sampler, Value);
|
|
}
|
|
else
|
|
{
|
|
// When 'Type' is passed in using a constant the optimizer can
|
|
// eliminate this entire switch statement:
|
|
|
|
switch (Type)
|
|
{
|
|
case D3DSAMP_ADDRESSU: D3DDevice_SetSamplerState_AddressU_Inline(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_ADDRESSV: D3DDevice_SetSamplerState_AddressV_Inline(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_ADDRESSW: D3DDevice_SetSamplerState_AddressW_Inline(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_BORDERCOLOR: D3DDevice_SetSamplerState_BorderColor_Inline(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_MAGFILTER: D3DDevice_SetSamplerState_MagFilter(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_MINFILTER: D3DDevice_SetSamplerState_MinFilter(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_MIPFILTER: D3DDevice_SetSamplerState_MipFilter_Inline(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_MIPMAPLODBIAS: D3DDevice_SetSamplerState_MipMapLodBias(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_MAXMIPLEVEL: D3DDevice_SetSamplerState_MaxMipLevel(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_MAXANISOTROPY: D3DDevice_SetSamplerState_MaxAnisotropy(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_MAGFILTERZ: D3DDevice_SetSamplerState_MagFilterZ(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_MINFILTERZ: D3DDevice_SetSamplerState_MinFilterZ(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_SEPARATEZFILTERENABLE: D3DDevice_SetSamplerState_SeparateZFilterEnable(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_MINMIPLEVEL: D3DDevice_SetSamplerState_MinMipLevel(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_TRILINEARTHRESHOLD: D3DDevice_SetSamplerState_TrilinearThreshold_Inline(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_ANISOTROPYBIAS: D3DDevice_SetSamplerState_AnisotropyBias(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_HGRADIENTEXPBIAS: D3DDevice_SetSamplerState_HGradientExpBias_Inline(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_VGRADIENTEXPBIAS: D3DDevice_SetSamplerState_VGradientExpBias_Inline(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_WHITEBORDERCOLORW: D3DDevice_SetSamplerState_WhiteBorderColorW_Inline(pDevice, Sampler, Value); break;
|
|
case D3DSAMP_POINTBORDERENABLE: D3DDevice_SetSamplerState_PointBorderEnable_Inline(pDevice, Sampler, Value); break;
|
|
|
|
#if defined(_DEBUG)
|
|
default: __debugbreak();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
D3DINLINE void D3DDevice_GetSamplerState(__in D3DDevice* pDevice, DWORD Sampler, D3DSAMPLERSTATETYPE Type, __out DWORD *pValue)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_GetSamplerState_ParameterCheck(pDevice, Sampler, Type);
|
|
#endif
|
|
|
|
if (!D3DISINTCONST(Type))
|
|
{
|
|
// Getting the state uses a function pointer table that assumes
|
|
// the pointers are 4 bytes in size. The pointer arithemetic for
|
|
// Type*(sizeof(ULONG_PTR)/sizeof(DWORD)) uses platform specific
|
|
// ULONG_PTR type, which is the size of pointer, that when compiled
|
|
// is either compiled away (when sizeof(ULONG_PTR)/sizeof(DWORD) == 1)
|
|
// or becomes the specific multiple of the byte size for a pointer
|
|
// on the specific platform to ensure proper incrementation of the
|
|
// GetState pointer.
|
|
|
|
*pValue = (*(D3DGETSAMPLERSTATECALL*)(((BYTE*) &pDevice->m_GetSamplerStateCall[0] + Type*(sizeof(ULONG_PTR)/sizeof(DWORD)))))(pDevice, Sampler);
|
|
}
|
|
else
|
|
{
|
|
switch (Type)
|
|
{
|
|
case D3DSAMP_ADDRESSU: *pValue = D3DDevice_GetSamplerState_AddressU(pDevice, Sampler); break;
|
|
case D3DSAMP_ADDRESSV: *pValue = D3DDevice_GetSamplerState_AddressV(pDevice, Sampler); break;
|
|
case D3DSAMP_ADDRESSW: *pValue = D3DDevice_GetSamplerState_AddressW(pDevice, Sampler); break;
|
|
case D3DSAMP_BORDERCOLOR: *pValue = D3DDevice_GetSamplerState_BorderColor(pDevice, Sampler); break;
|
|
case D3DSAMP_MAGFILTER: *pValue = D3DDevice_GetSamplerState_MagFilter(pDevice, Sampler); break;
|
|
case D3DSAMP_MINFILTER: *pValue = D3DDevice_GetSamplerState_MinFilter(pDevice, Sampler); break;
|
|
case D3DSAMP_MIPFILTER: *pValue = D3DDevice_GetSamplerState_MipFilter(pDevice, Sampler); break;
|
|
case D3DSAMP_MIPMAPLODBIAS: *pValue = D3DDevice_GetSamplerState_MipMapLodBias(pDevice, Sampler); break;
|
|
case D3DSAMP_MAXMIPLEVEL: *pValue = D3DDevice_GetSamplerState_MaxMipLevel(pDevice, Sampler); break;
|
|
case D3DSAMP_MAXANISOTROPY: *pValue = D3DDevice_GetSamplerState_MaxAnisotropy(pDevice, Sampler); break;
|
|
case D3DSAMP_MAGFILTERZ: *pValue = D3DDevice_GetSamplerState_MagFilterZ(pDevice, Sampler); break;
|
|
case D3DSAMP_MINFILTERZ: *pValue = D3DDevice_GetSamplerState_MinFilterZ(pDevice, Sampler); break;
|
|
case D3DSAMP_SEPARATEZFILTERENABLE: *pValue = D3DDevice_GetSamplerState_SeparateZFilterEnable(pDevice, Sampler); break;
|
|
case D3DSAMP_MINMIPLEVEL: *pValue = D3DDevice_GetSamplerState_MinMipLevel(pDevice, Sampler); break;
|
|
case D3DSAMP_TRILINEARTHRESHOLD: *pValue = D3DDevice_GetSamplerState_TrilinearThreshold(pDevice, Sampler); break;
|
|
case D3DSAMP_ANISOTROPYBIAS: *pValue = D3DDevice_GetSamplerState_AnisotropyBias(pDevice, Sampler); break;
|
|
case D3DSAMP_HGRADIENTEXPBIAS: *pValue = D3DDevice_GetSamplerState_HGradientExpBias(pDevice, Sampler); break;
|
|
case D3DSAMP_VGRADIENTEXPBIAS: *pValue = D3DDevice_GetSamplerState_VGradientExpBias(pDevice, Sampler); break;
|
|
case D3DSAMP_WHITEBORDERCOLORW: *pValue = D3DDevice_GetSamplerState_WhiteBorderColorW(pDevice, Sampler); break;
|
|
case D3DSAMP_POINTBORDERENABLE: *pValue = D3DDevice_GetSamplerState_PointBorderEnable(pDevice, Sampler); break;
|
|
|
|
#if defined(_DEBUG)
|
|
default: __debugbreak();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerAddressStates(__in D3DDevice* pDevice, DWORD Sampler, DWORD AddressU, DWORD AddressV, DWORD AddressW)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_ADDRESSU, AddressU);
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_ADDRESSV, AddressV);
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_ADDRESSW, AddressW);
|
|
#endif
|
|
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].ClampX = (GPUCLAMP)AddressU;
|
|
pDevice->m_Constants.TextureFetch[Sampler].ClampY = (GPUCLAMP)AddressV;
|
|
pDevice->m_Constants.TextureFetch[Sampler].ClampZ = (GPUCLAMP)AddressW;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerBorderStates(__in D3DDevice* pDevice, DWORD Sampler, DWORD BorderColor, DWORD WhiteBorderColorW, DWORD PointBorderEnable)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_BORDERCOLOR, BorderColor);
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_WHITEBORDERCOLORW, WhiteBorderColorW);
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_POINTBORDERENABLE, PointBorderEnable);
|
|
#endif
|
|
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].BorderColor = (BorderColor == 0) ? GPUBORDERCOLOR_ABGR_BLACK : GPUBORDERCOLOR_ABGR_WHITE;
|
|
pDevice->m_Constants.TextureFetch[Sampler].ForceBCWToMax = WhiteBorderColorW;
|
|
pDevice->m_Constants.TextureFetch[Sampler].ClampPolicy = (GPUCLAMPPOLICY)!PointBorderEnable;
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerSeparateZFilterStates(__in D3DDevice* pDevice, DWORD Sampler, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter, DWORD MinFilterZ, DWORD MagFilterZ, DWORD MaxAnisotropy)
|
|
{
|
|
static CONST GPUANISOFILTER anisoFilterMap[] =
|
|
{
|
|
GPUANISOFILTER_DISABLED, // 0
|
|
GPUANISOFILTER_DISABLED, // 1
|
|
GPUANISOFILTER_MAX2TO1, // 2
|
|
GPUANISOFILTER_MAX2TO1, // 3
|
|
GPUANISOFILTER_MAX4TO1, // 4
|
|
GPUANISOFILTER_MAX4TO1, // 5
|
|
GPUANISOFILTER_MAX4TO1, // 6
|
|
GPUANISOFILTER_MAX8TO1, // 7
|
|
GPUANISOFILTER_MAX8TO1, // 8
|
|
GPUANISOFILTER_MAX8TO1, // 9
|
|
GPUANISOFILTER_MAX8TO1, // 10
|
|
GPUANISOFILTER_MAX8TO1, // 11
|
|
GPUANISOFILTER_MAX8TO1, // 12
|
|
GPUANISOFILTER_MAX16TO1, // 13
|
|
GPUANISOFILTER_MAX16TO1, // 14
|
|
GPUANISOFILTER_MAX16TO1, // 15
|
|
GPUANISOFILTER_MAX16TO1, // 16
|
|
};
|
|
|
|
#if defined(_DEBUG)
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_MINFILTER, MinFilter);
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_MAGFILTER, MagFilter);
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_MIPFILTER, MipFilter);
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_MINFILTERZ, MinFilterZ);
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_MAGFILTERZ, MagFilterZ);
|
|
D3DDevice_SetSamplerState_ParameterCheck(pDevice, Sampler, D3DSAMP_MAXANISOTROPY, MaxAnisotropy);
|
|
#endif
|
|
|
|
Sampler = GPU_CONVERT_D3D_TO_HARDWARE_TEXTUREFETCHCONSTANT(Sampler);
|
|
pDevice->m_Constants.TextureFetch[Sampler].MinFilter = (MinFilter == D3DTEXF_ANISOTROPIC) ? D3DTEXF_LINEAR : MinFilter;
|
|
pDevice->m_Constants.TextureFetch[Sampler].MagFilter = (MagFilter == D3DTEXF_ANISOTROPIC)? D3DTEXF_LINEAR : MagFilter;
|
|
pDevice->m_Constants.TextureFetch[Sampler].MipFilter = MipFilter;
|
|
pDevice->m_Constants.TextureFetch[Sampler].VolMinFilter = MinFilterZ;
|
|
pDevice->m_Constants.TextureFetch[Sampler].VolMagFilter = MagFilterZ;
|
|
pDevice->m_Constants.TextureFetch[Sampler].MinAnisoWalk = (DWORD)(MinFilter == D3DTEXF_ANISOTROPIC);
|
|
pDevice->m_Constants.TextureFetch[Sampler].MagAnisoWalk = (DWORD)(MagFilter == D3DTEXF_ANISOTROPIC);
|
|
pDevice->m_Constants.TextureFetch[Sampler].AnisoFilter = (MinFilter == D3DTEXF_ANISOTROPIC || MagFilter == D3DTEXF_ANISOTROPIC) ? anisoFilterMap[MaxAnisotropy] : GPUANISOFILTER_DISABLED;
|
|
|
|
pDevice->m_MaxAnisotropy[Sampler] = (BYTE)MaxAnisotropy;
|
|
pDevice->m_ZFilter[Sampler] = (BYTE)(4 | (MinFilterZ << 1) | MagFilterZ);
|
|
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_TEXTUREFETCHCONSTANTS), D3DTag_SamplerMask(Sampler));
|
|
}
|
|
|
|
D3DINLINE void WINAPI D3DDevice_SetSamplerFilterStates(__in D3DDevice* pDevice, DWORD Sampler, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter, DWORD MaxAnisotropy)
|
|
{
|
|
DWORD minFilterZ = (MinFilter == D3DTEXF_ANISOTROPIC) ? D3DTEXF_LINEAR : MinFilter;
|
|
DWORD magFilterZ = (MagFilter == D3DTEXF_ANISOTROPIC) ? D3DTEXF_LINEAR : MagFilter;
|
|
BYTE oldZFilter = pDevice->m_ZFilter[Sampler];
|
|
D3DDevice_SetSamplerSeparateZFilterStates(pDevice, Sampler, MinFilter, MagFilter, MipFilter, minFilterZ, magFilterZ, MaxAnisotropy);
|
|
pDevice->m_ZFilter[Sampler] = (BYTE)(oldZFilter & ~4);
|
|
}
|
|
|
|
// Fast deferred shader constant setting
|
|
|
|
D3DINLINE void D3DDevice_BeginVertexShaderConstantF1(__in D3DDevice* pDevice, UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, UINT Vector4fCount)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_BeginShaderConstantF1_ParameterCheck(pDevice, FALSE, StartRegister, Vector4fCount);
|
|
#endif
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_VERTEXSHADERCONSTANTS), D3DTag_ShaderConstantMask(StartRegister, Vector4fCount));
|
|
*ppConstantData = &pDevice->m_Constants.VertexShaderF[StartRegister];
|
|
}
|
|
D3DINLINE void D3DDevice_BeginPixelShaderConstantF1(__in D3DDevice* pDevice, UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, UINT Vector4fCount)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_BeginShaderConstantF1_ParameterCheck(pDevice, TRUE, StartRegister, Vector4fCount);
|
|
#endif
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_PIXELSHADERCONSTANTS), D3DTag_ShaderConstantMask(StartRegister, Vector4fCount));
|
|
*ppConstantData = &pDevice->m_Constants.PixelShaderF[StartRegister];
|
|
}
|
|
D3DINLINE void D3DDevice_EndShaderConstantF1(__in D3DDevice* pDevice)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_EndShaderConstantF1_ParameterCheck(pDevice);
|
|
#endif
|
|
}
|
|
D3DINLINE void D3DDevice_EndShaderConstantF4(__in D3DDevice* pDevice)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_EndShaderConstantF4_ParameterCheck(pDevice);
|
|
#endif
|
|
}
|
|
|
|
// The following two inline routines are automatically called by the corresponding
|
|
// SetVertexShaderConstantF/SetPixelShaderConstantF APIs.
|
|
|
|
D3DINLINE void D3DDevice_SetVertexShaderConstantF1(__in D3DDevice* pDevice, UINT StartRegister, __in_ecount(4) CONST float* D3DRESTRICT pConstantData)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_SetVertexShaderConstantF_ParameterCheck(pDevice, StartRegister, pConstantData, 1);
|
|
#endif
|
|
// Copy into D3D's shadow state. Note that by copying a dword at a
|
|
// time, we let the optimizer recognize and remove redundant copies.
|
|
// That wouldn't be true if we used a vector copy. For example,
|
|
// this lets the compiler optimize the following so that the temporary
|
|
// store to the stack is completely eliminated from a sequence such
|
|
// as the following:
|
|
//
|
|
// float vector[4] = { x, y, z, w };
|
|
// pDevice->SetVertexShaderConstantF(Register, vector, 1);
|
|
|
|
D3DVECTOR4_SetX(&pDevice->m_Constants.VertexShaderF[StartRegister], pConstantData[0]);
|
|
D3DVECTOR4_SetY(&pDevice->m_Constants.VertexShaderF[StartRegister], pConstantData[1]);
|
|
D3DVECTOR4_SetZ(&pDevice->m_Constants.VertexShaderF[StartRegister], pConstantData[2]);
|
|
D3DVECTOR4_SetW(&pDevice->m_Constants.VertexShaderF[StartRegister], pConstantData[3]);
|
|
|
|
// Let D3D know that the constants were set:
|
|
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_VERTEXSHADERCONSTANTS), D3DTag_ShaderConstantMask(StartRegister, 1));
|
|
}
|
|
D3DINLINE void D3DDevice_SetPixelShaderConstantF1(D3DDevice* D3DRESTRICT pDevice, UINT StartRegister, __in_ecount(4) CONST float* D3DRESTRICT pConstantData)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_SetPixelShaderConstantF_ParameterCheck(pDevice, StartRegister, pConstantData, 1);
|
|
#endif
|
|
|
|
D3DVECTOR4_SetX(&pDevice->m_Constants.PixelShaderF[StartRegister], pConstantData[0]);
|
|
D3DVECTOR4_SetY(&pDevice->m_Constants.PixelShaderF[StartRegister], pConstantData[1]);
|
|
D3DVECTOR4_SetZ(&pDevice->m_Constants.PixelShaderF[StartRegister], pConstantData[2]);
|
|
D3DVECTOR4_SetW(&pDevice->m_Constants.PixelShaderF[StartRegister], pConstantData[3]);
|
|
|
|
D3DTagCollection_Set(&pDevice->m_Pending, D3DTag_Index(D3DTAG_PIXELSHADERCONSTANTS), D3DTag_ShaderConstantMask(StartRegister, 1));
|
|
}
|
|
|
|
// The following two inline routines are automatically called by the
|
|
// corresponding SetVertexShaderConstantF/SetPixelShaderConstantF routines.
|
|
// They special-case a count of "1" since that's typically the most frequent
|
|
// count specified, and inlining can reduce copies and avoid load-hit-store
|
|
// stalls.
|
|
//
|
|
// Note that all the conditionals here get compiled away by the optimizer.
|
|
|
|
D3DINLINE void D3DDevice_SetVertexShaderConstantF(__in D3DDevice* pDevice, UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount)
|
|
{
|
|
if (D3DISINTCONST(Vector4fCount))
|
|
{
|
|
if (Vector4fCount == 1)
|
|
{
|
|
D3DDevice_SetVertexShaderConstantF1(pDevice, StartRegister, pConstantData);
|
|
}
|
|
else
|
|
{
|
|
D3DDevice_SetVertexShaderConstantFN(pDevice, StartRegister, pConstantData, Vector4fCount, D3DTag_ShaderConstantMask(StartRegister, Vector4fCount));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
D3DDevice_SetVertexShaderConstantFN(pDevice, StartRegister, pConstantData, Vector4fCount, D3DTag_ShaderConstantMask(StartRegister, Vector4fCount));
|
|
}
|
|
}
|
|
|
|
D3DINLINE void D3DDevice_SetPixelShaderConstantF(__in D3DDevice* pDevice, UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount)
|
|
{
|
|
if (D3DISINTCONST(Vector4fCount))
|
|
{
|
|
if (Vector4fCount == 1)
|
|
{
|
|
D3DDevice_SetPixelShaderConstantF1(pDevice, StartRegister, pConstantData);
|
|
}
|
|
else
|
|
{
|
|
D3DDevice_SetPixelShaderConstantFN(pDevice, StartRegister, pConstantData, Vector4fCount, D3DTag_ShaderConstantMask(StartRegister, Vector4fCount));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
D3DDevice_SetPixelShaderConstantFN(pDevice, StartRegister, pConstantData, Vector4fCount, D3DTag_ShaderConstantMask(StartRegister, Vector4fCount));
|
|
}
|
|
}
|
|
|
|
// Unbuffered Graphics support
|
|
|
|
D3DINLINE void D3DDevice_GpuOwn(__in D3DDevice* pDevice, D3DTAG Tag)
|
|
{
|
|
DWORD index = D3DTag_Index(Tag);
|
|
UINT64 mask = D3DTag_Mask(Tag);
|
|
|
|
#if defined(_DEBUG)
|
|
D3DDevice_GpuOwn_ParameterCheck(pDevice, index, mask);
|
|
#endif
|
|
|
|
D3DTagCollection_Clear(&pDevice->m_Pending, index, mask);
|
|
|
|
}
|
|
D3DINLINE void D3DDevice_GpuOwnSubset(__in D3DDevice* pDevice, D3DTAG Tag, DWORD StartIndex, DWORD EndIndex)
|
|
{
|
|
DWORD index = D3DTag_Index(Tag);
|
|
UINT64 mask = D3DTag_SubsetMask(Tag, StartIndex, EndIndex);
|
|
|
|
#if defined(_DEBUG)
|
|
D3DDevice_GpuOwn_ParameterCheck(pDevice, index, mask);
|
|
#endif
|
|
|
|
D3DTagCollection_Clear(&pDevice->m_Pending, index, mask);
|
|
}
|
|
D3DINLINE void D3DDevice_GpuOwnVertexShaderConstantF(__in D3DDevice* pDevice, DWORD StartRegister, DWORD Vector4fCount)
|
|
{
|
|
DWORD index = D3DTag_Index(D3DTAG_VERTEXSHADERCONSTANTS);
|
|
UINT64 mask = D3DTag_ShaderConstantMask(StartRegister, Vector4fCount);
|
|
|
|
#if defined(_DEBUG)
|
|
D3DDevice_GpuOwn_ParameterCheck(pDevice, index, mask);
|
|
#endif
|
|
|
|
D3DTagCollection_Clear(&pDevice->m_Pending, index, mask);
|
|
}
|
|
D3DINLINE void D3DDevice_GpuOwnPixelShaderConstantF(__in D3DDevice* pDevice, DWORD StartRegister, DWORD Vector4fCount)
|
|
{
|
|
DWORD index = D3DTag_Index(D3DTAG_PIXELSHADERCONSTANTS);
|
|
UINT64 mask = D3DTag_ShaderConstantMask(StartRegister, Vector4fCount);
|
|
|
|
#if defined(_DEBUG)
|
|
D3DDevice_GpuOwn_ParameterCheck(pDevice, index, mask);
|
|
#endif
|
|
|
|
D3DTagCollection_Clear(&pDevice->m_Pending, index, mask);
|
|
}
|
|
D3DINLINE void D3DDevice_GpuOwnShaders(__in D3DDevice* pDevice)
|
|
{
|
|
D3DDevice_GpuOwn(pDevice, D3DTAG_VERTEXSHADER);
|
|
D3DDevice_GpuOwn(pDevice, D3DTAG_PIXELSHADER);
|
|
D3DDevice_GpuOwn(pDevice, D3DTAG_PROGRAMCONTROL);
|
|
D3DDevice_GpuOwn(pDevice, D3DTAG_FLOWCONSTANTS);
|
|
D3DDevice_GpuOwn(pDevice, D3DTAG_CONTEXTMISC);
|
|
D3DDevice_GpuOwn(pDevice, D3DTAG_INTERPOLATORCONTROL);
|
|
D3DDevice_GpuOwn(pDevice, D3DTAG_EDRAMMODECONTROL);
|
|
|
|
D3DDevice_SetVertexShader(pDevice, NULL);
|
|
}
|
|
|
|
D3DINLINE void D3DDevice_GpuDisown(__in D3DDevice* pDevice, D3DTAG Tag)
|
|
{
|
|
DWORD index = D3DTag_Index(Tag);
|
|
UINT64 mask = D3DTag_Mask(Tag);
|
|
#if defined(_DEBUG)
|
|
D3DDevice_GpuDisown_ParameterCheck(pDevice, index, mask);
|
|
#endif
|
|
|
|
D3DTagCollection_Set(&pDevice->m_Pending, index, mask);
|
|
}
|
|
D3DINLINE void D3DDevice_GpuDisownSubset(__in D3DDevice* pDevice, D3DTAG Tag, DWORD StartIndex, DWORD EndIndex)
|
|
{
|
|
DWORD index = D3DTag_Index(Tag);
|
|
UINT64 mask = D3DTag_SubsetMask(Tag, StartIndex, EndIndex);
|
|
|
|
#if defined(_DEBUG)
|
|
D3DDevice_GpuDisown_ParameterCheck(pDevice, index, mask);
|
|
#endif
|
|
|
|
D3DTagCollection_Set(&pDevice->m_Pending, index, mask);
|
|
}
|
|
D3DINLINE void D3DDevice_GpuDisownVertexShaderConstantF(__in D3DDevice* pDevice, DWORD StartRegister, DWORD Vector4fCount)
|
|
{
|
|
DWORD index = D3DTag_Index(D3DTAG_VERTEXSHADERCONSTANTS);
|
|
UINT64 mask = D3DTag_ShaderConstantMask(StartRegister, Vector4fCount);
|
|
|
|
#if defined(_DEBUG)
|
|
D3DDevice_GpuDisown_ParameterCheck(pDevice, index, mask);
|
|
#endif
|
|
|
|
D3DTagCollection_Set(&pDevice->m_Pending, index, mask);
|
|
}
|
|
D3DINLINE void D3DDevice_GpuDisownPixelShaderConstantF(__in D3DDevice* pDevice, DWORD StartRegister, DWORD Vector4fCount)
|
|
{
|
|
DWORD index = D3DTag_Index(D3DTAG_PIXELSHADERCONSTANTS);
|
|
UINT64 mask = D3DTag_ShaderConstantMask(StartRegister, Vector4fCount);
|
|
|
|
#if defined(_DEBUG)
|
|
D3DDevice_GpuDisown_ParameterCheck(pDevice, index, mask);
|
|
#endif
|
|
|
|
D3DTagCollection_Set(&pDevice->m_Pending, index, mask);
|
|
}
|
|
D3DINLINE void D3DDevice_GpuDisownShaders(__in D3DDevice* pDevice)
|
|
{
|
|
D3DDevice_GpuDisown(pDevice, D3DTAG_VERTEXSHADER);
|
|
D3DDevice_GpuDisown(pDevice, D3DTAG_PIXELSHADER);
|
|
D3DDevice_GpuDisown(pDevice, D3DTAG_PROGRAMCONTROL);
|
|
D3DDevice_GpuDisown(pDevice, D3DTAG_FLOWCONSTANTS);
|
|
D3DDevice_GpuDisown(pDevice, D3DTAG_CONTEXTMISC);
|
|
D3DDevice_GpuDisown(pDevice, D3DTAG_INTERPOLATORCONTROL);
|
|
D3DDevice_GpuDisown(pDevice, D3DTAG_EDRAMMODECONTROL);
|
|
}
|
|
|
|
D3DINLINE void D3DDevice_GpuEndShaderConstantF4(__in D3DDevice* pDevice)
|
|
{
|
|
#if defined(_DEBUG)
|
|
D3DDevice_GpuEndShaderConstantF4_ParameterCheck(pDevice);
|
|
#endif
|
|
}
|
|
|
|
// Compatibility wrappers.
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DDevice9_AddRef(__in D3DDevice *pThis) { return D3DDevice_AddRef(pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DDevice9_Release(__in D3DDevice *pThis) { return D3DDevice_Release(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetDirect3D(__in D3DDevice *pThis, __deref_out Direct3D **ppD3D9) { D3DDevice_GetDirect3D(pThis, ppD3D9); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetDeviceCaps(__in D3DDevice *pThis, __out D3DCAPS9 *pCaps) { D3DDevice_GetDeviceCaps(pThis, pCaps); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetDisplayMode(__in D3DDevice *pThis, UINT UnusedSwapChain, __out D3DDISPLAYMODE *pMode) { D3DDevice_GetDisplayMode(pThis, UnusedSwapChain, pMode); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetCreationParameters(__in D3DDevice *pThis, __out D3DDEVICE_CREATION_PARAMETERS *pParameters) { D3DDevice_GetCreationParameters(pThis, pParameters); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_Reset(__in D3DDevice *pThis, __in D3DPRESENT_PARAMETERS *pPresentationParameters) { return D3DDevice_Reset(pThis, pPresentationParameters); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_Present(__in D3DDevice *pThis, __in_opt CONST RECT *pUnusedSourceRect, __in_opt CONST RECT *pUnusedDestRect, __in_opt void *hUnusedDestWindowOverride, __in_opt void *pUnusedDirtyRegion) { D3DDevice_Present(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetRasterStatus(__in D3DDevice *pThis, UINT iUnusedSwapChain, __out D3DRASTER_STATUS *pRasterStatus) { D3DDevice_GetRasterStatus(pThis, pRasterStatus); D3DVOIDRETURN; }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_SetGammaRamp(__in D3DDevice *pThis, UINT iUnusedSwapChain, DWORD UnusedFlags, __in CONST D3DGAMMARAMP *pRamp) { D3DDevice_SetGammaRamp(pThis, UnusedFlags, pRamp); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GetGammaRamp(__in D3DDevice *pThis, UINT iUnusedSwapChain, __out D3DGAMMARAMP *pRamp) { D3DDevice_GetGammaRamp(pThis, pRamp); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_SetPWLGamma(__in D3DDevice *pThis, DWORD Flags, __in CONST D3DPWLGAMMA *pRamp) { D3DDevice_SetPWLGamma(pThis, Flags, pRamp); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GetPWLGamma(__in D3DDevice *pThis, __out D3DPWLGAMMA *pRamp) { D3DDevice_GetPWLGamma(pThis, pRamp); }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateTexture(__in D3DDevice *pThis, UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DTexture **ppTexture, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppTexture = (D3DTexture*) D3DDevice_CreateTexture(Width, Height, 1, Levels, Usage, Format, UnusedPool, D3DRTYPE_TEXTURE)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateVolumeTexture(__in D3DDevice *pThis, UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DVolumeTexture **ppVolumeTexture, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppVolumeTexture = (D3DVolumeTexture*) D3DDevice_CreateTexture(Width, Height, Depth, Levels, Usage, Format, UnusedPool, D3DRTYPE_VOLUMETEXTURE)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateCubeTexture(__in D3DDevice *pThis, UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DCubeTexture **ppCubeTexture, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppCubeTexture = (D3DCubeTexture*) D3DDevice_CreateTexture(EdgeLength, EdgeLength, 6, Levels, Usage, Format, UnusedPool, D3DRTYPE_CUBETEXTURE)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateArrayTexture(__in D3DDevice *pThis, UINT Width, UINT Height, UINT ArraySize, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DArrayTexture **ppArrayTexture, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppArrayTexture = (D3DArrayTexture*) D3DDevice_CreateTexture(Width, Height, ArraySize, Levels, Usage, Format, UnusedPool, D3DRTYPE_ARRAYTEXTURE)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateLineTexture(__in D3DDevice *pThis, UINT Width, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DLineTexture **ppTexture, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppTexture = (D3DLineTexture*) D3DDevice_CreateTexture(Width, 1, 1, Levels, Usage, Format, UnusedPool, D3DRTYPE_LINETEXTURE)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateVertexBuffer(__in D3DDevice *pThis, UINT Length, DWORD Usage, DWORD UnusedFVF, D3DPOOL UnusedPool, __deref_out D3DVertexBuffer **ppVertexBuffer, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppVertexBuffer = D3DDevice_CreateVertexBuffer(Length, Usage, UnusedPool)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateIndexBuffer(__in D3DDevice *pThis, UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DIndexBuffer **ppIndexBuffer, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppIndexBuffer = D3DDevice_CreateIndexBuffer(Length, Usage, Format, UnusedPool)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateVertexDeclaration(__in D3DDevice* pThis, __in CONST D3DVERTEXELEMENT9* pVertexElements, __deref_out D3DVertexDeclaration **ppVertexDeclaration) { return (*ppVertexDeclaration = D3DDevice_CreateVertexDeclaration(pVertexElements)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateRenderTarget(__in D3DDevice *pThis, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD UnusedMultisampleQuality, BOOL UnusedLockable, __deref_out D3DSurface **ppSurface, __in_opt CONST D3DSURFACE_PARAMETERS* pParameters) { return (*ppSurface = D3DDevice_CreateSurface(Width, Height, Format, MultiSample, pParameters)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateDepthStencilSurface(__in D3DDevice *pThis, UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD UnusedMultisampleQuality, BOOL UnusedDiscard, __deref_out D3DSurface **ppSurface, __in_opt CONST D3DSURFACE_PARAMETERS* pParameters) { return (*ppSurface = D3DDevice_CreateSurface(Width, Height, Format, MultiSample, pParameters)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetRenderTarget(__in D3DDevice *pThis, DWORD RenderTargetIndex, __in_opt D3DSurface *pRenderTarget) { D3DDevice_SetRenderTarget_External(pThis, RenderTargetIndex, pRenderTarget); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_GetRenderTarget(__in D3DDevice *pThis, DWORD RenderTargetIndex, __deref_out D3DSurface **ppRenderTarget) { return (*ppRenderTarget = D3DDevice_GetRenderTarget(pThis, RenderTargetIndex)) != NULL ? S_OK : D3DERR_NOTFOUND; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetDepthStencilSurface(__in D3DDevice *pThis, __in_opt D3DSurface *pZStencilSurface) { D3DDevice_SetDepthStencilSurface(pThis, pZStencilSurface); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_GetDepthStencilSurface(__in D3DDevice *pThis, __deref_out D3DSurface **ppZStencilSurface) { return (*ppZStencilSurface = D3DDevice_GetDepthStencilSurface(pThis)) != NULL ? S_OK : D3DERR_NOTFOUND; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_GetBackBuffer(__in D3DDevice *pThis, UINT UnusedSwapChain, UINT iUnusedBackBuffer, UINT UnusedType, __deref_out D3DSurface **ppBackBuffer) { return (*ppBackBuffer = D3DDevice_GetBackBuffer(pThis)) != NULL ? S_OK : D3DERR_NOTFOUND; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_GetFrontBuffer(__in D3DDevice *pThis, __deref_out D3DTexture **ppFrontBuffer) { return (*ppFrontBuffer = D3DDevice_GetFrontBuffer(pThis)) != NULL ? S_OK : D3DERR_NOTFOUND; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_BeginScene(__in D3DDevice *pThis) { D3DDevice_BeginScene(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EndScene(__in D3DDevice *pThis) { D3DDevice_EndScene(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_Clear(__in D3DDevice *pThis, DWORD Count, __in_opt CONST D3DRECT *pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil) { D3DDevice_Clear(pThis, Count, pRects, Flags, Color, Z, Stencil, FALSE); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_ClearF(__in D3DDevice *pThis, DWORD Flags, __in_opt CONST D3DRECT *pRect, __in_opt CONST D3DVECTOR4* pColor, float Z, DWORD Stencil) { D3DDevice_ClearF(pThis, Flags, pRect, pColor, Z, Stencil); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SynchronizeToPresentationInterval(__in D3DDevice *pThis) { D3DDevice_SynchronizeToPresentationInterval(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_Swap(__in D3DDevice *pThis, __in D3DBaseTexture* pFrontBuffer, __in_opt CONST D3DVIDEO_SCALER_PARAMETERS* pParameters) { D3DDevice_Swap(pThis, pFrontBuffer, pParameters); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_RenderSystemUI(__in D3DDevice *pThis) { D3DDevice_RenderSystemUI(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_QueryBufferSpace(__in D3DDevice* pDevice, __out DWORD* pUsed, __out DWORD* pRemaining) { D3DDevice_QueryBufferSpace(pDevice, pUsed, pRemaining); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetPredication(__in D3DDevice* pDevice, DWORD PredicationMask) { D3DDevice_SetPredication(pDevice, PredicationMask); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetPatchablePredication(__in D3DDevice* pDevice, DWORD PredicationMask, DWORD Identifier) { D3DDevice_SetPatchablePredication(pDevice, PredicationMask, Identifier); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_BeginTiling(__in D3DDevice* pDevice, DWORD Flags, DWORD Count, __in_ecount(Count) CONST D3DRECT* pTileRects, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil) { D3DDevice_BeginTiling(pDevice, Flags, Count, pTileRects, pClearColor, ClearZ, ClearStencil); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_EndTiling(__in D3DDevice* pDevice, DWORD ResolveFlags, __in_opt CONST D3DRECT* pResolveRects, __in_opt D3DBaseTexture* pDestTexture, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil, __in_opt CONST D3DRESOLVE_PARAMETERS* pParameters) { return D3DDevice_EndTiling(pDevice, ResolveFlags, pResolveRects, pDestTexture, pClearColor, ClearZ, ClearStencil, pParameters); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_BeginZPass(__in D3DDevice* pDevice, DWORD Flags) { D3DDevice_BeginZPass(pDevice, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_EndZPass(__in D3DDevice* pDevice) { return D3DDevice_EndZPass(pDevice); }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_InvokeRenderPass(__in D3DDevice* pDevice) { return D3DDevice_InvokeRenderPass(pDevice); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_BeginExport(__in D3DDevice* pDevice, DWORD Index, __in D3DResource* pResource, DWORD Flags) { D3DDevice_BeginExport(pDevice, Index, pResource, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EndExport(__in D3DDevice* pDevice, DWORD Index, __in D3DResource* pResource, DWORD Flags) { D3DDevice_EndExport(pDevice, Index, pResource, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetViewport(__in D3DDevice *pThis, __in CONST D3DVIEWPORT9 *pViewport) { D3DDevice_SetViewport(pThis, pViewport); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetViewport(__in D3DDevice *pThis, __out D3DVIEWPORT9 *pViewport) { D3DDevice_GetViewport(pThis, pViewport); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetRenderState(__in D3DDevice *pThis, D3DRENDERSTATETYPE State, DWORD Value) { D3DDevice_SetRenderState(pThis, State, Value); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetRenderState_Inline(__in D3DDevice *pThis, D3DRENDERSTATETYPE State, DWORD Value) { D3DDevice_SetRenderState(pThis, State, Value); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetRenderState(__in D3DDevice *pThis, D3DRENDERSTATETYPE State, __out DWORD *pValue) { D3DDevice_GetRenderState(pThis, State, pValue); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateStateBlock(__in D3DDevice *pThis, D3DSTATEBLOCKTYPE Type, __deref_out D3DStateBlock** ppSB) { return (*ppSB = D3DDevice_CreateStateBlock(pThis, Type)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetTexture(__in D3DDevice *pThis, DWORD Sampler, __deref_out D3DBaseTexture **ppTexture) { *ppTexture = D3DDevice_GetTexture(pThis, Sampler); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetTexture(__in D3DDevice *pThis, DWORD Sampler, __in_opt D3DBaseTexture *pTexture) { D3DDevice_SetTexture_Inline(pThis, Sampler, pTexture); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetSamplerState(__in D3DDevice *pThis, DWORD Sampler, D3DSAMPLERSTATETYPE Type, __out DWORD* pValue) { D3DDevice_GetSamplerState(pThis, Sampler, Type, pValue); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetSamplerState(__in D3DDevice *pThis, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value) { D3DDevice_SetSamplerState(pThis, Sampler, Type, Value); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetSamplerState_Inline(__in D3DDevice *pThis, DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value) { D3DDevice_SetSamplerState(pThis, Sampler, Type, Value); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetSamplerAddressStates(__in D3DDevice *pThis, DWORD Sampler, DWORD AddressU, DWORD AddressV, DWORD AddressW) { D3DDevice_SetSamplerAddressStates(pThis, Sampler, AddressU, AddressV, AddressW); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetSamplerBorderStates(__in D3DDevice *pThis, DWORD Sampler, DWORD BorderColor, DWORD WhiteBorderColorW, DWORD PointBorderEnable) { D3DDevice_SetSamplerBorderStates(pThis, Sampler, BorderColor, WhiteBorderColorW, PointBorderEnable); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetSamplerSeparateZFilterStates(__in D3DDevice *pThis, DWORD Sampler, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter, DWORD MinFilterZ, DWORD MagFilterZ, DWORD MaxAnisotropy) { D3DDevice_SetSamplerSeparateZFilterStates(pThis, Sampler, MinFilter, MagFilter, MipFilter, MinFilterZ, MagFilterZ, MaxAnisotropy); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetSamplerFilterStates(__in D3DDevice *pThis, DWORD Sampler, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter, DWORD MaxAnisotropy) { D3DDevice_SetSamplerFilterStates(pThis, Sampler, MinFilter, MagFilter, MipFilter, MaxAnisotropy); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_DrawVertices(__in D3DDevice *pThis, D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT VertexCount) { D3DDevice_DrawVertices(pThis, PrimitiveType, StartVertex, VertexCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_DrawIndexedVertices(__in D3DDevice *pThis, D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT StartIndex, UINT IndexCount) { D3DDevice_DrawIndexedVertices(pThis, PrimitiveType, BaseVertexIndex, StartIndex, IndexCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_DrawVerticesUP(__in D3DDevice *pThis, D3DPRIMITIVETYPE PrimitiveType, UINT VertexCount, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride) { D3DDevice_DrawVerticesUP(pThis, PrimitiveType, VertexCount, pVertexStreamZeroData, VertexStreamZeroStride); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_DrawIndexedVerticesUP(__in D3DDevice *pThis, D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertices, UINT IndexCount, __in CONST void *pIndexData, D3DFORMAT IndexDataFormat, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride) { D3DDevice_DrawIndexedVerticesUP(pThis, PrimitiveType, MinVertexIndex, NumVertices, IndexCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_DrawPrimitive(__in D3DDevice *pThis, D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) { D3DDevice_DrawVertices(pThis, PrimitiveType, StartVertex, D3DVERTEXCOUNT(PrimitiveType, PrimitiveCount)); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_DrawIndexedPrimitive(__in D3DDevice *pThis, D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT UnusedMinIndex, UINT UnusedNumIndices, UINT StartIndex, UINT PrimitiveCount) { D3DDevice_DrawIndexedVertices(pThis, PrimitiveType, BaseVertexIndex, StartIndex, D3DVERTEXCOUNT(PrimitiveType, PrimitiveCount)); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_DrawPrimitiveUP(__in D3DDevice *pThis, D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride) { D3DDevice_DrawVerticesUP(pThis, PrimitiveType, D3DVERTEXCOUNT(PrimitiveType, PrimitiveCount), pVertexStreamZeroData, VertexStreamZeroStride); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_DrawIndexedPrimitiveUP(__in D3DDevice *pThis, D3DPRIMITIVETYPE PrimitiveType, UINT MinIndex, UINT NumVertices, UINT PrimitiveCount, __in CONST void *pIndexData, D3DFORMAT IndexDataFormat, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride) { D3DDevice_DrawIndexedVerticesUP(pThis, PrimitiveType, MinIndex, NumVertices, D3DVERTEXCOUNT(PrimitiveType, PrimitiveCount), pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetVertexDeclaration(__in D3DDevice *pThis, __in_opt D3DVertexDeclaration *pDecl) { D3DDevice_SetVertexDeclaration(pThis, pDecl); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetVertexDeclaration(__in D3DDevice *pThis, __deref_out D3DVertexDeclaration **ppDecl) { *ppDecl = D3DDevice_GetVertexDeclaration(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetScissorRect(__in D3DDevice *pThis, __in CONST RECT* pRect) { D3DDevice_SetScissorRect(pThis, pRect); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetScissorRect(__in D3DDevice *pThis, __out RECT* pRect) { D3DDevice_GetScissorRect(pThis, pRect); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetFVF(__in D3DDevice *pThis, DWORD FVF) { D3DDevice_SetFVF(pThis, FVF); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetFVF(__in D3DDevice *pThis, __out DWORD* pFVF) { *pFVF = D3DDevice_GetFVF(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateVertexShader(__in D3DDevice *pThis, __in CONST DWORD *pFunction, __deref_out D3DVertexShader** ppShader) { return (*ppShader = D3DDevice_CreateVertexShader(pFunction)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetVertexShader(__in D3DDevice *pThis, __in_opt D3DVertexShader *pShader) { D3DDevice_SetVertexShader(pThis, pShader); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetVertexShader(__in D3DDevice *pThis, __deref_out D3DVertexShader **ppShader) { D3DDevice_GetVertexShader(pThis, ppShader); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetVertexShaderConstantB(__in D3DDevice *pThis, UINT StartRegister, __in_ecount(BoolCount) CONST BOOL *pConstantData, UINT BoolCount) { D3DDevice_SetVertexShaderConstantB(pThis, StartRegister, pConstantData, BoolCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetVertexShaderConstantF(__in D3DDevice *pThis, UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount) { D3DDevice_SetVertexShaderConstantF(pThis, StartRegister, pConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetVertexShaderConstantI(__in D3DDevice *pThis, UINT StartRegister, __in_ecount(4*Vector4iCount) CONST int *pConstantData, DWORD Vector4iCount) { D3DDevice_SetVertexShaderConstantI(pThis, StartRegister, pConstantData, Vector4iCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetVertexShaderConstantB(__in D3DDevice *pThis, UINT StartRegister, __out_ecount(BoolCount) BOOL *pConstantData, DWORD BoolCount) { D3DDevice_GetVertexShaderConstantB(pThis, StartRegister, pConstantData, BoolCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetVertexShaderConstantF(__in D3DDevice *pThis, UINT StartRegister, __out_ecount(4*Vector4fCount) float *pConstantData, DWORD Vector4fCount) { D3DDevice_GetVertexShaderConstantF(pThis, StartRegister, pConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetVertexShaderConstantI(__in D3DDevice *pThis, UINT StartRegister, __out_ecount(4*Vector4iCount) int *pConstantData, DWORD Vector4iCount) { D3DDevice_GetVertexShaderConstantI(pThis, StartRegister, pConstantData, Vector4iCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetVertexShaderConstantF_NotInline(__in D3DDevice *pThis, UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount) { D3DDevice_SetVertexShaderConstantFN(pThis, StartRegister, pConstantData, Vector4fCount, D3DTag_ShaderConstantMask(StartRegister, Vector4fCount)); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetStreamSource(__in D3DDevice *pThis, UINT StreamNumber, __in_opt D3DVertexBuffer *pStreamData, UINT OffsetInBytes, UINT Stride) { D3DDevice_SetStreamSource_Inline(pThis, StreamNumber, pStreamData, OffsetInBytes, Stride); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetStreamSource(__in D3DDevice *pThis, UINT StreamNumber, __deref_out D3DVertexBuffer **ppStreamData, __out UINT *pOffsetInBytes, __out UINT *pStride) { *ppStreamData = D3DDevice_GetStreamSource(pThis, StreamNumber, pOffsetInBytes, pStride); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetIndices(__in D3DDevice *pThis, __in_opt D3DIndexBuffer *pIndexData) { D3DDevice_SetIndices(pThis, pIndexData); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetIndices(__in D3DDevice *pThis, __deref_out D3DIndexBuffer **ppIndexData) { *ppIndexData = D3DDevice_GetIndices(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreatePixelShader(__in D3DDevice *pThis, __in CONST DWORD *pFunction, __deref_out D3DPixelShader** ppShader) { return (*ppShader = D3DDevice_CreatePixelShader(pFunction)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetPixelShader(__in D3DDevice *pThis, __in_opt D3DPixelShader* pShader) { D3DDevice_SetPixelShader(pThis, pShader); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetPixelShader(__in D3DDevice *pThis, __deref_out D3DPixelShader** ppShader) { D3DDevice_GetPixelShader(pThis, ppShader); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetPixelShaderConstantB(__in D3DDevice *pThis, UINT StartRegister, __in_ecount(BoolCount) CONST BOOL *pConstantData, UINT BoolCount) { D3DDevice_SetPixelShaderConstantB(pThis, StartRegister, pConstantData, BoolCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetPixelShaderConstantF(__in D3DDevice *pThis, UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount) { D3DDevice_SetPixelShaderConstantF(pThis, StartRegister, pConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetPixelShaderConstantI(__in D3DDevice *pThis, UINT StartRegister, __in_ecount(4*Vector4iCount) CONST int *pConstantData, DWORD Vector4iCount) { D3DDevice_SetPixelShaderConstantI(pThis, StartRegister, pConstantData, Vector4iCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetPixelShaderConstantB(__in D3DDevice *pThis, UINT StartRegister, __out_ecount(BoolCount) BOOL *pConstantData, DWORD BoolCount) { D3DDevice_GetPixelShaderConstantB(pThis, StartRegister, pConstantData, BoolCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetPixelShaderConstantF(__in D3DDevice *pThis, UINT StartRegister, __out_ecount(4*Vector4fCount) float *pConstantData, DWORD Vector4fCount) { D3DDevice_GetPixelShaderConstantF(pThis, StartRegister, pConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetPixelShaderConstantI(__in D3DDevice *pThis, UINT StartRegister, __out_ecount(4*Vector4iCount) int *pConstantData, DWORD Vector4iCount) { D3DDevice_GetPixelShaderConstantI(pThis, StartRegister, pConstantData, Vector4iCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetPixelShaderConstantF_NotInline(__in D3DDevice *pThis, UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount) { D3DDevice_SetPixelShaderConstantFN(pThis, StartRegister, pConstantData, Vector4fCount, D3DTag_ShaderConstantMask(StartRegister, Vector4fCount)); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetClipPlane(__in D3DDevice *pThis, DWORD Index, __in_ecount(4) CONST float* pPlane) { D3DDevice_SetClipPlane(pThis, Index, pPlane); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetClipPlane(__in D3DDevice *pThis, DWORD Index, __out_ecount(4) float* pPlane) { D3DDevice_GetClipPlane(pThis, Index, pPlane); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateQuery(__in D3DDevice *pThis, D3DQUERYTYPE Type, __deref_out D3DQuery** ppQuery) { if (ppQuery == NULL) { return ((Type == D3DQUERYTYPE_EVENT) || (Type == D3DQUERYTYPE_OCCLUSION)) ? S_OK : D3DERR_NOTAVAILABLE; } else { return (*ppQuery = D3DDevice_CreateQueryTiled(pThis, Type, 1)) != NULL ? S_OK : E_OUTOFMEMORY; } }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateQueryTiled(__in D3DDevice *pThis, D3DQUERYTYPE Type, DWORD TileCount, __deref_out D3DQuery** ppQuery) { if (ppQuery == NULL) { return ((Type == D3DQUERYTYPE_EVENT) || (Type == D3DQUERYTYPE_OCCLUSION)) ? S_OK : D3DERR_NOTAVAILABLE; } else { return (*ppQuery = D3DDevice_CreateQueryTiled(pThis, Type, TileCount)) != NULL ? S_OK : E_OUTOFMEMORY; } }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateConstantBuffer(UINT VectorCount, DWORD Usage, __deref_out D3DConstantBuffer **ppConstantBuffer) { return (*ppConstantBuffer = D3DDevice_CreateConstantBuffer(VectorCount, Usage)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateCommandBuffer(UINT Size, DWORD Flags, __deref_out D3DCommandBuffer **ppCommandBuffer) { return (*ppCommandBuffer = D3DDevice_CreateCommandBuffer(Size, Flags)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateGrowableCommandBuffer(DWORD Flags, __in D3DALLOCATECALLBACK pAllocateCallback, __in D3DFREECALLBACK pFreeCallback, __in D3DQUERYCALLBACK pQueryCallback, DWORD CallbackContext, DWORD SegmentSize, __deref_out D3DCommandBuffer** ppCommandBuffer) { return (*ppCommandBuffer = D3DDevice_CreateGrowableCommandBuffer(Flags, pAllocateCallback, pFreeCallback, pQueryCallback, CallbackContext, SegmentSize)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_Resolve(__in D3DDevice* pThis, DWORD Flags, __in_opt CONST D3DRECT *pSourceRect, __in D3DBaseTexture *pDestTexture, __in_opt CONST D3DPOINT *pDestPoint, UINT DestLevel, UINT DestSliceOrFace, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil, __in_opt CONST D3DRESOLVE_PARAMETERS* pParameters) { D3DDevice_Resolve(pThis, Flags, pSourceRect, pDestTexture, pDestPoint, DestLevel, DestSliceOrFace, pClearColor, ClearZ, ClearStencil, pParameters); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_AcquireThreadOwnership(__in D3DDevice* pThis) { D3DDevice_AcquireThreadOwnership(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_ReleaseThreadOwnership(__in D3DDevice* pThis) { D3DDevice_ReleaseThreadOwnership(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetThreadOwnership(__in D3DDevice* pThis, DWORD ThreadID) { D3DDevice_SetThreadOwnership(pThis, ThreadID); D3DVOIDRETURN; }
|
|
D3DINLINE DWORD WINAPI IDirect3DDevice9_QueryThreadOwnership(__in D3DDevice* pThis) { return D3DDevice_QueryThreadOwnership(pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DDevice9_IsBusy(__in D3DDevice *pThis) { return D3DDevice_IsBusy(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_BlockUntilIdle(__in D3DDevice *pThis) { D3DDevice_BlockUntilIdle(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_InsertCallback(__in D3DDevice *pThis, D3DCALLBACKTYPE Type, __in_opt D3DCALLBACK pCallback, DWORD Context) { D3DDevice_InsertCallback(pThis, Type, pCallback, Context); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetVerticalBlankCallback(__in D3DDevice *pThis, __in_opt D3DVBLANKCALLBACK pCallback) { D3DDevice_SetVerticalBlankCallback(pThis, pCallback); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetSwapCallback(__in D3DDevice *pThis, __in D3DSWAPCALLBACK pCallback) { D3DDevice_SetSwapCallback(pThis, pCallback); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_DrawTessellatedPrimitive(__in D3DDevice *pThis, D3DTESSPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) { D3DDevice_DrawTessellatedVertices(pThis, PrimitiveType, StartVertex, D3DTESSVERTEXCOUNT(PrimitiveType, PrimitiveCount)); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_DrawIndexedTessellatedPrimitive(__in D3DDevice *pThis, D3DTESSPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT StartIndex, UINT PrimitiveCount) { D3DDevice_DrawIndexedTessellatedVertices(pThis, PrimitiveType, BaseVertexIndex, StartIndex, D3DTESSVERTEXCOUNT(PrimitiveType, PrimitiveCount)); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_SetRingBufferParameters(__in D3DDevice *pThis, __in_opt CONST D3DRING_BUFFER_PARAMETERS *pParameters) { return D3DDevice_SetRingBufferParameters(pThis, pParameters); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_XpsBegin(__in D3DDevice* pThis, DWORD Flags) { D3DDevice_XpsBegin(pThis, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_XpsEnd(__in D3DDevice* pThis) { return D3DDevice_XpsEnd(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_XpsSetCallback(__in D3DDevice* pThis, __in D3DXpsCallback pCallback, __in_opt void* pContext, DWORD Flags) { D3DDevice_XpsSetCallback(pThis, pCallback, pContext, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_XpsSubmit(__in D3DDevice* pThis, DWORD InstanceCount, __in_bcount(Size) CONST void* pData, DWORD Size) { D3DDevice_XpsSubmit(pThis, InstanceCount, pData, Size); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_XpsSetPredication(__in D3DDevice* pThis, DWORD Predication) { D3DDevice_XpsSetPredication(pThis, Predication); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_XpsSetPredicationFromVisibility(__in D3DDevice* pThis, HANDLE VisibilityHandle) { D3DDevice_XpsSetPredicationFromVisibility(pThis, VisibilityHandle); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_XpsSetPredicationFromQuery(__in D3DDevice* pThis, __in_opt IDirect3DQuery9* pQuery) { D3DDevice_XpsSetPredicationFromQuery(pThis, pQuery); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_BeginVertices(__in D3DDevice *pThis, D3DPRIMITIVETYPE PrimitiveType, UINT VertexCount, UINT VertexStreamZeroStride, __deref_out_bcount(VertexCount*VertexStreamZeroStride) void**ppVertexData) { return (*ppVertexData = D3DDevice_BeginVertices(pThis, PrimitiveType, VertexCount, VertexStreamZeroStride)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EndVertices(__in D3DDevice *pThis) { D3DDevice_EndVertices(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_BeginIndexedVertices(__in D3DDevice *pThis, D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT NumVertices, UINT IndexCount, D3DFORMAT IndexDataFormat, UINT VertexStreamZeroStride, __deref_out void** ppIndexData, __deref_out_bcount(NumVertices*VertexStreamZeroStride) void** ppVertexData) { return D3DDevice_BeginIndexedVertices(pThis, PrimitiveType, BaseVertexIndex, NumVertices, IndexCount, IndexDataFormat, VertexStreamZeroStride, ppIndexData, ppVertexData); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EndIndexedVertices(__in D3DDevice *pThis) { D3DDevice_EndIndexedVertices(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE DWORD WINAPI IDirect3DDevice9_InsertFence(__in D3DDevice *pThis) { return D3DDevice_InsertFence(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_BlockOnFence(__in D3DDevice *pThis, DWORD Fence) { D3DDevice_BlockOnFence(Fence); D3DVOIDRETURN; }
|
|
D3DINLINE BOOL WINAPI IDirect3DDevice9_IsFencePending(__in D3DDevice *pThis, DWORD Fence) { return D3DDevice_IsFencePending(Fence); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetBlendState(__in D3DDevice *pThis, DWORD RenderTargetIndex, D3DBLENDSTATE BlendState) { D3DDevice_SetBlendState(pThis, RenderTargetIndex, BlendState); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetBlendState(__in D3DDevice *pThis, DWORD RenderTargetIndex, __out D3DBLENDSTATE* pBlendState) { D3DDevice_GetBlendState(pThis, RenderTargetIndex, pBlendState); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetVertexFetchConstant(__in D3DDevice *pThis, UINT VertexFetchRegister, __in D3DVertexBuffer* pVertexBuffer, UINT Offset) { D3DDevice_SetVertexFetchConstant(pThis, VertexFetchRegister, pVertexBuffer, Offset); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetTextureFetchConstant(__in D3DDevice *pThis, UINT TextureFetchRegister, __in D3DBaseTexture* pTexture) { D3DDevice_SetTextureFetchConstant(pThis, TextureFetchRegister, pTexture); D3DVOIDRETURN; }
|
|
D3DINLINE float WINAPI IDirect3DDevice9_GetCounter(__in D3DDevice* pThis, D3DCOUNTER CounterID) { return D3DDevice_GetCounter(pThis, CounterID);}
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetSafeLevel(__in D3DDevice* pThis, DWORD Flags, DWORD Level) { D3DDevice_SetSafeLevel(pThis, Flags, Level); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetSafeLevel(__in D3DDevice* pThis, DWORD* pFlags, __out DWORD* pLevel) { D3DDevice_GetSafeLevel(pThis, pFlags, pLevel); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetHangCallback(__in D3DDevice* pThis, D3DHANGCALLBACK pCallback) { D3DDevice_SetHangCallback(pThis, pCallback); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_BeginConditionalSurvey(__in D3DDevice* pThis, DWORD Identifier, DWORD Flags) { D3DDevice_BeginConditionalSurvey(pThis, Identifier, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EndConditionalSurvey(__in D3DDevice* pThis, DWORD Flags) {D3DDevice_EndConditionalSurvey(pThis, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_BeginConditionalRendering(__in D3DDevice* pThis, DWORD Identifier) { D3DDevice_BeginConditionalRendering(pThis, Identifier); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EndConditionalRendering(__in D3DDevice* pThis) { D3DDevice_EndConditionalRendering(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_PersistDisplay(__in D3DDevice* pThis, __in D3DTexture* pFrontBuffer, __in_opt CONST D3DVIDEO_SCALER_PARAMETERS* pParameters) { return D3DDevice_PersistDisplay(pThis, pFrontBuffer, pParameters); }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_GetPersistedTexture(__in D3DDevice* pThis, __deref_out D3DTexture** pFrontBuffer) { return D3DDevice_GetPersistedTexture(pThis, pFrontBuffer); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_Suspend(__in D3DDevice* pThis) { D3DDevice_Suspend(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_Resume(__in D3DDevice* pThis) { D3DDevice_Resume(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreatePerfCounters(__in D3DDevice *pThis, __deref_out D3DPerfCounters** ppCounters, UINT NumInstances) { return (*ppCounters = D3DDevice_CreatePerfCounters(pThis, NumInstances)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EnablePerfCounters(__in D3DDevice* pThis, BOOL Enable) { D3DDevice_EnablePerfCounters(pThis, Enable); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetPerfCounterEvents(__in D3DDevice* pThis, __in CONST D3DPERFCOUNTER_EVENTS* pEvents, DWORD Flags) { D3DDevice_SetPerfCounterEvents(pThis, pEvents, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_QueryPerfCounters(__in D3DDevice* pThis, __in D3DPerfCounters* pCounters, DWORD Flags) { D3DDevice_QueryPerfCounters(pThis, pCounters, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE DWORD WINAPI IDirect3DDevice9_GetNumPasses(__in D3DDevice* pThis) { return D3DDevice_GetNumPasses(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetShaderInstructionAllocation(__in D3DDevice* pThis, DWORD Flags, DWORD VertexShaderBase, DWORD PixelShaderBase) { D3DDevice_SetShaderInstructionAllocation(pThis, Flags, VertexShaderBase, PixelShaderBase); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetShaderGPRAllocation(__in D3DDevice* pThis, DWORD Flags, DWORD VertexShaderCount, DWORD PixelShaderCount) { D3DDevice_SetShaderGPRAllocation(pThis, Flags, VertexShaderCount, PixelShaderCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetShaderGPRAllocation(__in D3DDevice* pThis, __out DWORD* pFlags, __out DWORD* pVertexShaderCount, __out DWORD* pPixelShaderCount) { D3DDevice_GetShaderGPRAllocation(pThis, pFlags, pVertexShaderCount, pPixelShaderCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetScreenExtentQueryMode(__in D3DDevice* pThis, D3DSCREENEXTENTQUERYMODE Mode) { D3DDevice_SetScreenExtentQueryMode(pThis, Mode); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetScreenExtentQueryMode(__in D3DDevice* pThis, __out D3DSCREENEXTENTQUERYMODE* pMode) { D3DDevice_GetScreenExtentQueryMode(pThis, pMode); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_BeginVertexShaderConstantF1(__in D3DDevice* pThis, UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, UINT Vector4fCount) { D3DDevice_BeginVertexShaderConstantF1(pThis, StartRegister, ppConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EndVertexShaderConstantF1(__in D3DDevice* pThis) { D3DDevice_EndShaderConstantF1(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_BeginPixelShaderConstantF1(__in D3DDevice* pThis, UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, UINT Vector4fCount) { D3DDevice_BeginPixelShaderConstantF1(pThis, StartRegister, ppConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EndPixelShaderConstantF1(__in D3DDevice* pThis) { D3DDevice_EndShaderConstantF1(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_BeginVertexShaderConstantF4(__in D3DDevice* pThis, UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppCachedConstantData, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppWriteCombinedConstantData, UINT Vector4fCount) { return D3DDevice_BeginShaderConstantF4(pThis, FALSE, StartRegister, ppCachedConstantData, ppWriteCombinedConstantData, Vector4fCount); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EndVertexShaderConstantF4(__in D3DDevice* pThis) { D3DDevice_EndShaderConstantF4(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_BeginPixelShaderConstantF4(__in D3DDevice* pThis, UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppCachedConstantData, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppWriteCombinedConstantData, UINT Vector4fCount) { return D3DDevice_BeginShaderConstantF4(pThis, TRUE, StartRegister, ppCachedConstantData, ppWriteCombinedConstantData, Vector4fCount); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EndPixelShaderConstantF4(__in D3DDevice* pThis) { D3DDevice_EndShaderConstantF4(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE DWORD WINAPI IDirect3DDevice9_GetCurrentFence(__in D3DDevice* pThis) { return D3DDevice_GetCurrentFence(); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_InvalidateGpuCache(__in D3DDevice* pThis, __in_bcount(Size) void* pBaseAddress, DWORD Size, DWORD Flags) { D3DDevice_InvalidateGpuCache(pThis, pBaseAddress, Size, Flags ); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_InvalidateResourceGpuCache(__in D3DDevice* pThis, __in D3DResource* pResource, DWORD Flags) { D3DDevice_InvalidateResourceGpuCache(pThis, pResource, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_FlushHiZStencil(__in D3DDevice* pThis, D3DFHZS_FLUSHTYPE FlushType) { D3DDevice_FlushHiZStencil(pThis, FlushType); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_UnsetAll(__in D3DDevice* pThis) { D3DDevice_UnsetAll(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE DWORD WINAPI IDirect3DDevice9_GetDeviceState(__in D3DDevice* pThis) { return D3DDevice_GetDeviceState(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetBlockCallback(__in D3DDevice* pThis, DWORD Flags, __in_opt D3DBLOCKCALLBACK pCallback) { D3DDevice_SetBlockCallback(pThis, Flags, pCallback); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetSurfaces(__in D3DDevice* pThis, __in CONST D3DSURFACES* pSurfaces, DWORD Flags) { D3DDevice_SetSurfaces(pThis, pSurfaces, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_BeginCommandBuffer(__in D3DDevice* pThis, __in D3DCommandBuffer* pCommandBuffer, DWORD Flags, __in_opt CONST D3DTAGCOLLECTION* pInheritTags, __in_opt CONST D3DTAGCOLLECTION* pPersistTags, __in_opt CONST D3DRECT* pTilingRects, DWORD TileCount) { D3DDevice_BeginCommandBuffer(pThis, pCommandBuffer, Flags, pInheritTags, pPersistTags, pTilingRects, TileCount); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_EndCommandBuffer(__in D3DDevice* pThis) { return D3DDevice_EndCommandBuffer(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_RunCommandBuffer(__in D3DDevice* pThis, __in D3DCommandBuffer* pCommandBuffer, DWORD PredicationSelect) { D3DDevice_RunCommandBuffer(pThis, pCommandBuffer, PredicationSelect); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_InsertAsyncCommandBufferCall(__in D3DDevice* pThis, __in D3DAsyncCommandBufferCall* pAsyncCommandBufferCall, DWORD PredicationSelect, DWORD Flags) { return D3DDevice_InsertAsyncCommandBufferCall(pThis, pAsyncCommandBufferCall, PredicationSelect, Flags ); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetCommandBufferPredication(__in D3DDevice* pThis, DWORD TilePredication, DWORD RunPredication) { D3DDevice_SetCommandBufferPredication(pThis, TilePredication, RunPredication); D3DVOIDRETURN; }
|
|
D3DINLINE DWORD WINAPI IDirect3DDevice9_InsertMarker(__in D3DDevice* pThis) { return D3DDevice_InsertMarker(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_Nop(__in D3DDevice* pThis, DWORD Count) { D3DDevice_Nop(pThis, Count); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_QuerySwapStatus(__in D3DDevice* pDevice, __out D3DSWAP_STATUS* pSwapStatus) { D3DDevice_QuerySwapStatus(pDevice, pSwapStatus); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetViewportF(__in D3DDevice* pDevice, __in CONST D3DVIEWPORTF9* pViewportF) { D3DDevice_SetViewportF(pDevice, pViewportF); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_GetViewportF(__in D3DDevice* pDevice, __out D3DVIEWPORTF9* pViewportF) { D3DDevice_GetViewportF(pDevice, pViewportF); D3DVOIDRETURN; }
|
|
D3DINLINE HANDLE WINAPI IDirect3DDevice9_BeginVisibilitySurvey(__in D3DDevice* pDevice, DWORD Flags) { return D3DDevice_BeginVisibilitySurvey(pDevice, Flags); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_EndVisibilitySurvey(__in D3DDevice* pDevice, HANDLE VisibilityHandle) { D3DDevice_EndVisibilitySurvey(pDevice, VisibilityHandle); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SetSwapMode(__in D3DDevice* pDevice, BOOL Asynchronous) { D3DDevice_SetSwapMode(pDevice, Asynchronous); D3DVOIDRETURN; }
|
|
D3DINLINE D3DASYNCBLOCK WINAPI IDirect3DDevice9_InsertBlockOnAsyncResources(__in D3DDevice* pDevice, DWORD WriteCount, __in_ecount_opt(WriteCount) D3DResource* CONST* pWriteResourceList, DWORD ReadCount, __in_ecount_opt(ReadCount) D3DResource* CONST* pReadResourceList, DWORD Flags) { return D3DDevice_InsertBlockOnAsyncResources(pDevice, WriteCount, pWriteResourceList, ReadCount, pReadResourceList, Flags); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DDevice9_SignalAsyncResources(__in D3DDevice* pDevice, D3DASYNCBLOCK AsyncBlock) { D3DDevice_SignalAsyncResources(pDevice, AsyncBlock); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateAsyncCommandBufferCall(__in D3DDevice* pThis, __in_opt D3DTAGCOLLECTION* pInheritTags, __in_opt D3DTAGCOLLECTION* pPersistTags, DWORD NumSegments, DWORD Flags, D3DAsyncCommandBufferCall** ppAsyncCall ) { return (*ppAsyncCall = D3DDevice_CreateAsyncCommandBufferCall(pThis, pInheritTags, pPersistTags, NumSegments, Flags)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreatePerfCounterBatch(__in D3DDevice *pThis, UINT NumSlots, UINT NumTiles, DWORD Flags, __deref_out D3DPerfCounterBatch** ppBatch) { return (*ppBatch = D3DDevice_CreatePerfCounterBatch(pThis, NumSlots, NumTiles, Flags)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_CreateOcclusionQueryBatch(__in D3DDevice* pThis, UINT NumSlots, UINT NumTiles, __deref_out D3DOcclusionQueryBatch** ppBatch) { return (*ppBatch = D3DDevice_CreateOcclusionQueryBatch(pThis, NumSlots, NumTiles)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuOwn(__in D3DDevice* pThis, D3DTAG Tag) { D3DDevice_GpuOwn(pThis, Tag); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuOwnSubset(__in D3DDevice* pThis, D3DTAG Tag, DWORD StartIndex, DWORD EndIndex) { D3DDevice_GpuOwnSubset(pThis, Tag, StartIndex, EndIndex); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuOwnVertexShaderConstantF(__in D3DDevice* pThis, DWORD StartRegister, DWORD Vector4fCount) { D3DDevice_GpuOwnVertexShaderConstantF(pThis, StartRegister, Vector4fCount); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuOwnPixelShaderConstantF(__in D3DDevice* pThis, DWORD StartRegister, DWORD Vector4fCount) { D3DDevice_GpuOwnPixelShaderConstantF(pThis, StartRegister, Vector4fCount); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuOwnShaders(__in D3DDevice* pThis) { D3DDevice_GpuOwnShaders(pThis); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuDisown(__in D3DDevice* pThis, D3DTAG Tag) { D3DDevice_GpuDisown(pThis, Tag); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuDisownSubset(__in D3DDevice* pThis, D3DTAG Tag, DWORD StartIndex, DWORD EndIndex) { D3DDevice_GpuDisownSubset(pThis, Tag, StartIndex, EndIndex); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuDisownVertexShaderConstantF(__in D3DDevice* pThis, DWORD StartRegister, DWORD Vector4fCount) { D3DDevice_GpuDisownVertexShaderConstantF(pThis, StartRegister, Vector4fCount); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuDisownPixelShaderConstantF(__in D3DDevice* pThis, DWORD StartRegister, DWORD Vector4fCount) { D3DDevice_GpuDisownPixelShaderConstantF(pThis, StartRegister, Vector4fCount); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuDisownShaders(__in D3DDevice* pThis) { D3DDevice_GpuDisownShaders(pThis); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuDisownAll(__in D3DDevice* pThis) { D3DDevice_GpuDisownAll(pThis); }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_GpuBeginVertexShaderConstantF4(__in D3DDevice* pThis, UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, DWORD Vector4fCount) { return (*ppConstantData = D3DDevice_GpuBeginShaderConstantF4(pThis, FALSE, StartRegister, Vector4fCount)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuEndVertexShaderConstantF4(__in D3DDevice* pThis) { D3DDevice_GpuEndShaderConstantF4(pThis); }
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_GpuBeginPixelShaderConstantF4(__in D3DDevice* pThis, UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, DWORD Vector4fCount) { return (*ppConstantData = D3DDevice_GpuBeginShaderConstantF4(pThis, TRUE, StartRegister, Vector4fCount)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuEndPixelShaderConstantF4(__in D3DDevice* pThis) { D3DDevice_GpuEndShaderConstantF4(pThis); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuLoadVertexShaderConstantF4(__in D3DDevice* pThis, UINT StartRegister, DWORD Vector4fCount, __in D3DConstantBuffer* pConstantBuffer, DWORD OffsetInVectors) { D3DDevice_GpuLoadShaderConstantF4(pThis, FALSE, StartRegister, Vector4fCount, pConstantBuffer, OffsetInVectors); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuLoadPixelShaderConstantF4(__in D3DDevice* pThis, UINT StartRegister, DWORD Vector4fCount, __in D3DConstantBuffer* pConstantBuffer, DWORD OffsetInVectors) { D3DDevice_GpuLoadShaderConstantF4(pThis, TRUE, StartRegister, Vector4fCount, pConstantBuffer, OffsetInVectors); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuLoadVertexShaderConstantF4Pointer(__in D3DDevice* pThis, UINT StartRegister, __in_bcount(4*sizeof(FLOAT)*Vector4fCount) CONST void* pConstantData, DWORD Vector4fCount) { D3DDevice_GpuLoadShaderConstantF4Pointer(pThis, FALSE, StartRegister, pConstantData, Vector4fCount); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuLoadPixelShaderConstantF4Pointer(__in D3DDevice* pThis, UINT StartRegister, __in_bcount(4*sizeof(FLOAT)*Vector4fCount) CONST void* pConstantData, DWORD Vector4fCount) { D3DDevice_GpuLoadShaderConstantF4Pointer(pThis, TRUE, StartRegister, pConstantData, Vector4fCount); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuLoadShaders(__in D3DDevice* pThis, __in D3DVertexShader* pVertexShader, __in_opt D3DPixelShader* pPixelShader, __in_opt CONST GPUFLOW_CONSTANTS* pFlowConstants) { D3DDevice_GpuLoadShaders(pThis, pVertexShader, pPixelShader, pFlowConstants); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuLoadShadersFast(__in D3DDevice* pThis, __in D3DVertexShader* pVertexShader, __in_opt D3DPixelShader* pPixelShader, __in_opt CONST GPUFLOW_CONSTANTS* pFlowConstants, DWORD Flags) { D3DDevice_GpuLoadShadersFast(pThis, pVertexShader, pPixelShader, pFlowConstants, Flags); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuSetVertexFetchConstant(__in D3DDevice* pThis, DWORD VertexFetchRegister, __in_opt D3DVertexBuffer* pVertexBuffer0, DWORD OffsetInBytes0, __in_opt D3DVertexBuffer* pVertexBuffer1, DWORD OffsetInBytes1, __in_opt D3DVertexBuffer* pVertexBuffer2, DWORD OffsetInBytes2) { D3DDevice_GpuSetVertexFetchConstant(pThis, VertexFetchRegister, pVertexBuffer0, OffsetInBytes0, pVertexBuffer1, OffsetInBytes1, pVertexBuffer2, OffsetInBytes2); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuSetTextureFetchConstant(__in D3DDevice* pThis, DWORD TextureFetchRegister, __in D3DBaseTexture* pTexture) { IDirect3DDevice9_GpuSetTextureFetchConstant(pThis, TextureFetchRegister, pTexture); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuSetColorMask(__in D3DDevice* pThis, __in const GPU_COLORMASK* pColorMask) { D3DDevice_GpuSetColorMask(pThis, pColorMask->dword); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuSetBlendFactor(__in D3DDevice* pThis, __in const D3DCOLORVALUE* pColor) { D3DDevice_GpuSetBlendFactor(pThis, pColor->r, pColor->g, pColor->b, pColor->a); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuSetAlphaRef(__in D3DDevice* pThis, float Ref) { D3DDevice_GpuSetAlphaRef(pThis, Ref); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuSetBlendControl(__in D3DDevice* pThis, DWORD RenderTargetIndex, __in const GPU_BLENDCONTROL* pBlendControl) { D3DDevice_GpuSetBlendControl(pThis, RenderTargetIndex, pBlendControl->dword); }
|
|
D3DINLINE void WINAPI IDirect3DDevice9_GpuSetColorControl(__in D3DDevice* pThis, __in const GPU_COLORCONTROL* pColorControl) { D3DDevice_GpuSetColorControl(pThis, pColorControl->dword); }
|
|
|
|
// Make the PIX methods disappear on retail builds
|
|
//
|
|
D3DINLINE DWORD WINAPI IDirect3DDevice9_PixBeginNamedEvent(__in D3DDevice* pThis, DWORD Color, __in_z CONST char *szName, ...)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS)
|
|
va_list arglist;
|
|
va_start(arglist, szName);
|
|
return D3DDevice_PixBeginNamedEvent(pThis, Color, szName, arglist);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
D3DINLINE DWORD WINAPI IDirect3DDevice9_PixEndNamedEvent(__in D3DDevice* pThis)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS)
|
|
return D3DDevice_PixEndNamedEvent(pThis);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
D3DINLINE void WINAPI IDirect3DDevice9_PixSetMarker(__in D3DDevice* pThis, DWORD Color, __in_z CONST char *szName, ...)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS)
|
|
va_list arglist;
|
|
va_start(arglist, szName);
|
|
D3DDevice_PixSetMarker(pThis, Color, szName, arglist);
|
|
#endif
|
|
}
|
|
|
|
// Make the PIX Texture Tracking methods disappear on retail and x86 builds
|
|
//
|
|
D3DINLINE void WINAPI IDirect3DDevice9_PixIgnoreTexture(__in D3DDevice* pThis, __in D3DBaseTexture* pTexture)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixIgnoreTexture(pThis, pTexture);
|
|
#endif
|
|
}
|
|
|
|
D3DINLINE void WINAPI IDirect3DDevice9_PixStopIgnoringTexture(__in D3DDevice* pThis, __in D3DBaseTexture* pTexture)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixStopIgnoringTexture(pThis, pTexture);
|
|
#endif
|
|
}
|
|
|
|
D3DINLINE void WINAPI IDirect3DDevice9_PixIgnoreMemoryRange(__in D3DDevice* pThis, __in_bcount(Size) const void* pBaseAddress, DWORD Size)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixIgnoreMemoryRange(pThis, pBaseAddress, Size);
|
|
#endif
|
|
}
|
|
|
|
D3DINLINE void WINAPI IDirect3DDevice9_PixStopIgnoringMemoryRange(__in D3DDevice* pThis, __in_bcount(Size) const void* pBaseAddress, DWORD Size)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixStopIgnoringMemoryRange(pThis, pBaseAddress, Size);
|
|
#endif
|
|
}
|
|
|
|
D3DINLINE HRESULT WINAPI IDirect3DDevice9_PixSetTextureName(__in D3DDevice* pThis, __in D3DBaseTexture* pTexture, __in_z const char* pName)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
return D3DDevice_PixSetTextureName(pThis, pTexture, pName);
|
|
#else
|
|
return S_OK;
|
|
#endif
|
|
}
|
|
|
|
D3DINLINE void WINAPI IDirect3DDevice9_PixReportNewTexture(__in D3DDevice* pThis, __in D3DBaseTexture* pTexture)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixReportNewTexture(pThis, pTexture);
|
|
#endif
|
|
}
|
|
|
|
D3DINLINE void WINAPI IDirect3DDevice9_PixReportDeletedTexture(__in D3DDevice* pThis, __in D3DBaseTexture* pTexture, BOOL BaseDeleted, BOOL MipDeleted)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixReportDeletedTexture(pThis, pTexture, BaseDeleted, MipDeleted);
|
|
#endif
|
|
}
|
|
|
|
D3DINLINE void WINAPI IDirect3DDevice9_PixReportMovedMemoryRange(__in D3DDevice* pThis, __in_bcount(Size) const void* pDestinationAddress, __in_bcount(Size) const void* pSourceAddress, DWORD Size)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixReportMovedMemoryRange(pThis, pDestinationAddress, pSourceAddress, Size);
|
|
#endif
|
|
}
|
|
|
|
D3DINLINE void WINAPI IDirect3DDevice9_PixReportFreedMemoryRange(__in D3DDevice* pThis, __in_bcount(Size) const void* pAddress, DWORD Size)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixReportFreedMemoryRange(pThis, pAddress, Size);
|
|
#endif
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE ULONG WINAPI D3DDevice::AddRef() { return D3DDevice_AddRef(this); }
|
|
D3DMINLINE ULONG WINAPI D3DDevice::Release() { return D3DDevice_Release(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetDirect3D(__deref_out Direct3D **ppD3D9) { D3DDevice_GetDirect3D(this, ppD3D9); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetDeviceCaps(__out D3DCAPS9 *pCaps) { D3DDevice_GetDeviceCaps(this, pCaps); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetDisplayMode(UINT UnusedSwapChain, __out D3DDISPLAYMODE *pMode) { D3DDevice_GetDisplayMode(this, UnusedSwapChain, pMode); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetCreationParameters(__out D3DDEVICE_CREATION_PARAMETERS *pParameters) { D3DDevice_GetCreationParameters(this, pParameters); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::Reset(__in D3DPRESENT_PARAMETERS *pPresentationParameters) { return D3DDevice_Reset(this, pPresentationParameters); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::Present(__in_opt CONST RECT *pUnusedSourceRect, __in_opt CONST RECT *pUnusedDestRect, __in_opt void *hUnusedDestWindowOverride, __in_opt void *pUnusedDirtyRegion) { D3DDevice_Present(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetRasterStatus(UINT iUnusedSwapChain, __out D3DRASTER_STATUS *pRasterStatus) { D3DDevice_GetRasterStatus(this, pRasterStatus); D3DVOIDRETURN; }
|
|
D3DMINLINE void WINAPI D3DDevice::SetGammaRamp(UINT iUnusedSwapChain, DWORD UnusedFlags, __in CONST D3DGAMMARAMP *pRamp) { D3DDevice_SetGammaRamp(this, UnusedFlags, pRamp); }
|
|
D3DMINLINE void WINAPI D3DDevice::GetGammaRamp(UINT iUnusedSwapChain, __out D3DGAMMARAMP *pRamp) { D3DDevice_GetGammaRamp(this, pRamp); }
|
|
D3DMINLINE void WINAPI D3DDevice::SetPWLGamma(DWORD Flags, __in CONST D3DPWLGAMMA *pRamp) { D3DDevice_SetPWLGamma(this, Flags, pRamp); }
|
|
D3DMINLINE void WINAPI D3DDevice::GetPWLGamma(__out D3DPWLGAMMA *pRamp) { D3DDevice_GetPWLGamma(this, pRamp); }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateTexture(UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DTexture **ppTexture, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppTexture = (D3DTexture*) D3DDevice_CreateTexture(Width, Height, 1, Levels, Usage, Format, UnusedPool, D3DRTYPE_TEXTURE)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateVolumeTexture(UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DVolumeTexture **ppVolumeTexture, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppVolumeTexture = (D3DVolumeTexture*) D3DDevice_CreateTexture(Width, Height, Depth, Levels, Usage, Format, UnusedPool, D3DRTYPE_VOLUMETEXTURE)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateCubeTexture(UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DCubeTexture **ppCubeTexture, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppCubeTexture = (D3DCubeTexture*) D3DDevice_CreateTexture(EdgeLength, EdgeLength, 6, Levels, Usage, Format, UnusedPool, D3DRTYPE_CUBETEXTURE)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateArrayTexture(UINT Width, UINT Height, UINT ArraySize, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DArrayTexture **ppArrayTexture, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppArrayTexture = (D3DArrayTexture*) D3DDevice_CreateTexture(Width, Height, ArraySize, Levels, Usage, Format, UnusedPool, D3DRTYPE_ARRAYTEXTURE)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateLineTexture(UINT Width, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DLineTexture **ppTexture, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppTexture = (D3DLineTexture*) D3DDevice_CreateTexture(Width, 1, 1, Levels, Usage, Format, UnusedPool, D3DRTYPE_LINETEXTURE)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateVertexBuffer(UINT Length, DWORD Usage, DWORD UnusedFVF, D3DPOOL UnusedPool, __deref_out D3DVertexBuffer **ppVertexBuffer, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppVertexBuffer = D3DDevice_CreateVertexBuffer(Length, Usage, UnusedPool)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL UnusedPool, __deref_out D3DIndexBuffer **ppIndexBuffer, __in_opt HANDLE* pUnusedSharedHandle) { return (*ppIndexBuffer = D3DDevice_CreateIndexBuffer(Length, Usage, Format, UnusedPool)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateVertexDeclaration(__in CONST D3DVERTEXELEMENT9* pVertexElements, __deref_out D3DVertexDeclaration **ppVertexDeclaration) { return (*ppVertexDeclaration = D3DDevice_CreateVertexDeclaration(pVertexElements)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateRenderTarget(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD UnusedMultisampleQuality, BOOL UnusedLockable, __deref_out D3DSurface **ppSurface, __in_opt CONST D3DSURFACE_PARAMETERS* pParameters) { return (*ppSurface = D3DDevice_CreateSurface(Width, Height, Format, MultiSample, pParameters)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateDepthStencilSurface(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD UnusedMultisampleQuality, BOOL UnusedDiscard, __deref_out D3DSurface **ppSurface, __in_opt CONST D3DSURFACE_PARAMETERS* pParameters) { return (*ppSurface = D3DDevice_CreateSurface(Width, Height, Format, MultiSample, pParameters)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetRenderTarget(DWORD RenderTargetIndex, __in_opt D3DSurface *pRenderTarget) { D3DDevice_SetRenderTarget_External(this, RenderTargetIndex, pRenderTarget); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::GetRenderTarget(DWORD RenderTargetIndex, __deref_out D3DSurface **ppRenderTarget) { return (*ppRenderTarget = D3DDevice_GetRenderTarget(this, RenderTargetIndex)) != NULL ? S_OK : D3DERR_NOTFOUND; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetDepthStencilSurface(__in_opt D3DSurface *pZStencilSurface) { D3DDevice_SetDepthStencilSurface(this, pZStencilSurface); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::GetDepthStencilSurface(__deref_out D3DSurface **ppZStencilSurface) { return (*ppZStencilSurface = D3DDevice_GetDepthStencilSurface(this)) != NULL ? S_OK : D3DERR_NOTFOUND; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::GetBackBuffer(UINT UnusedSwapChain, UINT iUnusedBackBuffer, UINT UnusedType, __deref_out D3DSurface **ppBackBuffer) { return (*ppBackBuffer = D3DDevice_GetBackBuffer(this)) != NULL ? S_OK : D3DERR_NOTFOUND; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::GetFrontBuffer(__deref_out D3DTexture **ppFrontBuffer) { return (*ppFrontBuffer = D3DDevice_GetFrontBuffer(this)) != NULL ? S_OK : D3DERR_NOTFOUND; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::BeginScene() { D3DDevice_BeginScene(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EndScene() { D3DDevice_EndScene(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::Clear(DWORD Count, __in_opt CONST D3DRECT *pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil) { D3DDevice_Clear(this, Count, pRects, Flags, Color, Z, Stencil, FALSE); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::ClearF(DWORD Flags, __in_opt CONST D3DRECT *pRect, __in_opt CONST D3DVECTOR4* pColor, float Z, DWORD Stencil) { D3DDevice_ClearF(this, Flags, pRect, pColor, Z, Stencil); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SynchronizeToPresentationInterval() { D3DDevice_SynchronizeToPresentationInterval(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::Swap(__in D3DBaseTexture* pFrontBuffer, __in_opt CONST D3DVIDEO_SCALER_PARAMETERS* pParameters) { D3DDevice_Swap(this, pFrontBuffer, pParameters); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::RenderSystemUI() { D3DDevice_RenderSystemUI(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::QueryBufferSpace(__out DWORD* pUsed, __out DWORD* pRemaining) { D3DDevice_QueryBufferSpace(this, pUsed, pRemaining); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetPredication(DWORD PredicationMask) { D3DDevice_SetPredication(this, PredicationMask); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetPatchablePredication(DWORD PredicationMask, DWORD Identifier) { D3DDevice_SetPatchablePredication(this, PredicationMask, Identifier); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::BeginTiling(DWORD Flags, DWORD Count, __in_ecount(Count) CONST D3DRECT* pTileRects, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil) { D3DDevice_BeginTiling(this, Flags, Count, pTileRects, pClearColor, ClearZ, ClearStencil); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::EndTiling(DWORD ResolveFlags, __in_opt CONST D3DRECT* pResolveRects, __in_opt D3DBaseTexture* pDestTexture, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil, __in_opt CONST D3DRESOLVE_PARAMETERS* pParameters) { return D3DDevice_EndTiling(this, ResolveFlags, pResolveRects, pDestTexture, pClearColor, ClearZ, ClearStencil, pParameters); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::BeginZPass(DWORD Flags) { D3DDevice_BeginZPass(this, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::EndZPass() { return D3DDevice_EndZPass(this); }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::InvokeRenderPass() { return D3DDevice_InvokeRenderPass(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::BeginExport(DWORD Index, __in D3DResource* pResource, DWORD Flags) { D3DDevice_BeginExport(this, Index, pResource, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EndExport(DWORD Index, __in D3DResource* pResource, DWORD Flags) { D3DDevice_EndExport(this, Index, pResource, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetViewport(__in CONST D3DVIEWPORT9 *pViewport) { D3DDevice_SetViewport(this, pViewport); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetViewport(__out D3DVIEWPORT9 *pViewport) { D3DDevice_GetViewport(this, pViewport); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetRenderState(D3DRENDERSTATETYPE State, DWORD Value) { D3DDevice_SetRenderState(this, State, Value); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetRenderState_Inline(D3DRENDERSTATETYPE State, DWORD Value) { D3DDevice_SetRenderState(this, State, Value); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetRenderState(D3DRENDERSTATETYPE State, __out DWORD *pValue) { D3DDevice_GetRenderState(this, State, pValue); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateStateBlock(D3DSTATEBLOCKTYPE Type, __deref_out D3DStateBlock** ppSB) { return (*ppSB = D3DDevice_CreateStateBlock(this, Type)) != NULL ? S_OK : E_OUTOFMEMORY;}
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetTexture(DWORD Sampler, __deref_out D3DBaseTexture **ppTexture) { *ppTexture = D3DDevice_GetTexture(this, Sampler); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetTexture(DWORD Sampler, __in_opt D3DBaseTexture *pTexture) { D3DDevice_SetTexture_Inline(this, Sampler, pTexture); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, __out DWORD* pValue) { D3DDevice_GetSamplerState(this, Sampler, Type, pValue); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value) { D3DDevice_SetSamplerState(this, Sampler, Type, Value); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetSamplerState_Inline(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value) { D3DDevice_SetSamplerState(this, Sampler, Type, Value); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetSamplerAddressStates(DWORD Sampler, DWORD AddressU, DWORD AddressV, DWORD AddressW) { D3DDevice_SetSamplerAddressStates(this, Sampler, AddressU, AddressV, AddressW); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetSamplerBorderStates(DWORD Sampler, DWORD BorderColor, DWORD WhiteBorderColorW, DWORD PointBorderEnable) { D3DDevice_SetSamplerBorderStates(this, Sampler, BorderColor, WhiteBorderColorW, PointBorderEnable); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetSamplerSeparateZFilterStates(DWORD Sampler, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter, DWORD MinFilterZ, DWORD MagFilterZ, DWORD MaxAnisotropy) { D3DDevice_SetSamplerSeparateZFilterStates(this, Sampler, MinFilter, MagFilter, MipFilter, MinFilterZ, MagFilterZ, MaxAnisotropy); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetSamplerFilterStates(DWORD Sampler, DWORD MinFilter, DWORD MagFilter, DWORD MipFilter, DWORD MaxAnisotropy) { D3DDevice_SetSamplerFilterStates(this, Sampler, MinFilter, MagFilter, MipFilter, MaxAnisotropy); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::DrawVertices(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT VertexCount) { D3DDevice_DrawVertices(this, PrimitiveType, StartVertex, VertexCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::DrawIndexedVertices(D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT StartIndex, UINT IndexCount) { D3DDevice_DrawIndexedVertices(this, PrimitiveType, BaseVertexIndex, StartIndex, IndexCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::DrawVerticesUP(D3DPRIMITIVETYPE PrimitiveType, UINT VertexCount, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride) { D3DDevice_DrawVerticesUP(this, PrimitiveType, VertexCount, pVertexStreamZeroData, VertexStreamZeroStride); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::DrawIndexedVerticesUP(D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertices, UINT IndexCount, __in CONST void *pIndexData, D3DFORMAT IndexDataFormat, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride) { D3DDevice_DrawIndexedVerticesUP(this, PrimitiveType, MinVertexIndex, NumVertices, IndexCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) { D3DDevice_DrawVertices(this, PrimitiveType, StartVertex, D3DVERTEXCOUNT(PrimitiveType, PrimitiveCount)); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT UnusedMinIndex, UINT UnusedNumIndices, UINT StartIndex, UINT PrimitiveCount) { D3DDevice_DrawIndexedVertices(this, PrimitiveType, BaseVertexIndex, StartIndex, D3DVERTEXCOUNT(PrimitiveType, PrimitiveCount)); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride) { D3DDevice_DrawVerticesUP(this, PrimitiveType, D3DVERTEXCOUNT(PrimitiveType, PrimitiveCount), pVertexStreamZeroData, VertexStreamZeroStride); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT MinIndex, UINT NumVertices, UINT PrimitiveCount, __in CONST void *pIndexData, D3DFORMAT IndexDataFormat, __in CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride) { D3DDevice_DrawIndexedVerticesUP(this, PrimitiveType, MinIndex, NumVertices, D3DVERTEXCOUNT(PrimitiveType, PrimitiveCount), pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetVertexDeclaration(__in_opt D3DVertexDeclaration *pDecl) { D3DDevice_SetVertexDeclaration(this, pDecl); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetVertexDeclaration(__deref_out D3DVertexDeclaration **ppDecl) { *ppDecl = D3DDevice_GetVertexDeclaration(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetScissorRect(__in CONST RECT* pRect) { D3DDevice_SetScissorRect(this, pRect); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetScissorRect(__out RECT* pRect) { D3DDevice_GetScissorRect(this, pRect); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetFVF(DWORD FVF) { D3DDevice_SetFVF(this, FVF); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetFVF(__out DWORD* pFVF) { *pFVF = D3DDevice_GetFVF(this); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateVertexShader(__in CONST DWORD *pFunction, __deref_out D3DVertexShader** ppShader) { return (*ppShader = D3DDevice_CreateVertexShader(pFunction)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetVertexShader(__in_opt D3DVertexShader *pShader) { D3DDevice_SetVertexShader(this, pShader); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetVertexShader(__deref_out D3DVertexShader **ppShader) { D3DDevice_GetVertexShader(this, ppShader); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetVertexShaderConstantF(UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount) { D3DDevice_SetVertexShaderConstantF(this, StartRegister, pConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetVertexShaderConstantF(UINT StartRegister, __out_ecount(4*Vector4fCount) float *pConstantData, DWORD Vector4fCount) { D3DDevice_GetVertexShaderConstantF(this, StartRegister, pConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetVertexShaderConstantI(UINT StartRegister, __in_ecount(4*Vector4iCount) CONST int *pConstantData, DWORD Vector4iCount) { D3DDevice_SetVertexShaderConstantI(this, StartRegister, pConstantData, Vector4iCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetVertexShaderConstantI(UINT StartRegister, __out_ecount(4*Vector4iCount) int *pConstantData, DWORD Vector4iCount) { D3DDevice_GetVertexShaderConstantI(this, StartRegister, pConstantData, Vector4iCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetVertexShaderConstantB(UINT StartRegister, __in_ecount(BoolCount) CONST BOOL *pConstantData, UINT BoolCount) { D3DDevice_SetVertexShaderConstantB(this, StartRegister, pConstantData, BoolCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetVertexShaderConstantB(UINT StartRegister, __out_ecount(BoolCount) BOOL *pConstantData, DWORD BoolCount) { D3DDevice_GetVertexShaderConstantB(this, StartRegister, pConstantData, BoolCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetVertexShaderConstantF_NotInline(UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount) { D3DDevice_SetVertexShaderConstantFN(this, StartRegister, pConstantData, Vector4fCount, D3DTag_ShaderConstantMask(StartRegister, Vector4fCount)); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetStreamSource(UINT StreamNumber, __in_opt D3DVertexBuffer *pStreamData, UINT OffsetInBytes, UINT Stride) { D3DDevice_SetStreamSource_Inline(this, StreamNumber, pStreamData, OffsetInBytes, Stride); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetStreamSource(UINT StreamNumber, __deref_out D3DVertexBuffer **ppStreamData, __out UINT *pOffsetInBytes, __out UINT *pStride) { *ppStreamData = D3DDevice_GetStreamSource(this, StreamNumber, pOffsetInBytes, pStride); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetIndices(__in_opt D3DIndexBuffer *pIndexData) { D3DDevice_SetIndices(this, pIndexData); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetIndices(__deref_out D3DIndexBuffer **ppIndexData) { *ppIndexData = D3DDevice_GetIndices(this); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreatePixelShader(__in CONST DWORD *pFunction, __deref_out D3DPixelShader** ppShader) { return (*ppShader = D3DDevice_CreatePixelShader(pFunction)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetPixelShader(__in_opt D3DPixelShader* pShader) { D3DDevice_SetPixelShader(this, pShader); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetPixelShader(__deref_out D3DPixelShader** ppShader) { D3DDevice_GetPixelShader(this, ppShader); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetPixelShaderConstantF(UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount) { D3DDevice_SetPixelShaderConstantF(this, StartRegister, pConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetPixelShaderConstantF(UINT StartRegister, __out_ecount(4*Vector4fCount) float *pConstantData, DWORD Vector4fCount) { D3DDevice_GetPixelShaderConstantF(this, StartRegister, pConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetPixelShaderConstantI(UINT StartRegister, __in_ecount(4*Vector4iCount) CONST int *pConstantData, DWORD Vector4iCount) { D3DDevice_SetPixelShaderConstantI(this, StartRegister, pConstantData, Vector4iCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetPixelShaderConstantI(UINT StartRegister, __out_ecount(4*Vector4iCount) int *pConstantData, DWORD Vector4iCount) { D3DDevice_GetPixelShaderConstantI(this, StartRegister, pConstantData, Vector4iCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetPixelShaderConstantB(UINT StartRegister, __in_ecount(BoolCount) CONST BOOL *pConstantData, UINT BoolCount) { D3DDevice_SetPixelShaderConstantB(this, StartRegister, pConstantData, BoolCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetPixelShaderConstantB(UINT StartRegister, __out_ecount(BoolCount) BOOL *pConstantData, DWORD BoolCount) { D3DDevice_GetPixelShaderConstantB(this, StartRegister, pConstantData, BoolCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetPixelShaderConstantF_NotInline(UINT StartRegister, __in_ecount(4*Vector4fCount) CONST float *pConstantData, DWORD Vector4fCount) { D3DDevice_SetPixelShaderConstantFN(this, StartRegister, pConstantData, Vector4fCount, D3DTag_ShaderConstantMask(StartRegister, Vector4fCount)); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetClipPlane(DWORD Index, __in_ecount(4) CONST float* pPlane) { D3DDevice_SetClipPlane(this, Index, pPlane); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetClipPlane(DWORD Index, __out_ecount(4) float* pPlane) { D3DDevice_GetClipPlane(this, Index, pPlane); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateQuery(D3DQUERYTYPE Type, __deref_out D3DQuery** ppQuery) { if (ppQuery == NULL) { return ((Type == D3DQUERYTYPE_EVENT) || (Type == D3DQUERYTYPE_OCCLUSION)) ? S_OK : D3DERR_NOTAVAILABLE; } else { return (*ppQuery = D3DDevice_CreateQueryTiled(this, Type, 1)) != NULL ? S_OK : E_OUTOFMEMORY; } }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateQueryTiled(D3DQUERYTYPE Type, DWORD TileCount, __deref_out D3DQuery** ppQuery) { if (ppQuery == NULL) { return ((Type == D3DQUERYTYPE_EVENT) || (Type == D3DQUERYTYPE_OCCLUSION)) ? S_OK : D3DERR_NOTAVAILABLE; } else { return (*ppQuery = D3DDevice_CreateQueryTiled(this, Type, TileCount)) != NULL ? S_OK : E_OUTOFMEMORY; } }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateConstantBuffer(UINT VectorCount, DWORD Usage, __deref_out D3DConstantBuffer **ppConstantBuffer) { return (*ppConstantBuffer = D3DDevice_CreateConstantBuffer(VectorCount, Usage)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateCommandBuffer(UINT Size, DWORD Flags, __deref_out D3DCommandBuffer **ppCommandBuffer) { return (*ppCommandBuffer = D3DDevice_CreateCommandBuffer(Size, Flags)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateGrowableCommandBuffer(DWORD Flags, __in D3DALLOCATECALLBACK pAllocateCallback, __in D3DFREECALLBACK pFreeCallback, __in D3DQUERYCALLBACK pQueryCallback, DWORD CallbackContext, DWORD SegmentSize, __deref_out D3DCommandBuffer** ppCommandBuffer) { return (*ppCommandBuffer = D3DDevice_CreateGrowableCommandBuffer(Flags, pAllocateCallback, pFreeCallback, pQueryCallback, CallbackContext, SegmentSize)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::Resolve(DWORD Flags, __in_opt CONST D3DRECT *pSourceRect, __in D3DBaseTexture *pDestTexture, __in_opt CONST D3DPOINT *pDestPoint, UINT DestLevel, UINT DestSliceOrFace, __in_opt CONST D3DVECTOR4* pClearColor, float ClearZ, DWORD ClearStencil, __in_opt CONST D3DRESOLVE_PARAMETERS* pParameters) { D3DDevice_Resolve(this, Flags, pSourceRect, pDestTexture, pDestPoint, DestLevel, DestSliceOrFace, pClearColor, ClearZ, ClearStencil, pParameters); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::AcquireThreadOwnership() { D3DDevice_AcquireThreadOwnership(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::ReleaseThreadOwnership() { D3DDevice_ReleaseThreadOwnership(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetThreadOwnership(DWORD ThreadID) { D3DDevice_SetThreadOwnership(this, ThreadID); D3DVOIDRETURN; }
|
|
D3DMINLINE DWORD WINAPI D3DDevice::QueryThreadOwnership() { return D3DDevice_QueryThreadOwnership(this); }
|
|
D3DMINLINE BOOL WINAPI D3DDevice::IsBusy() { return D3DDevice_IsBusy(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::BlockUntilIdle() { D3DDevice_BlockUntilIdle(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::InsertCallback(D3DCALLBACKTYPE Type, __in_opt D3DCALLBACK pCallback, DWORD Context) { D3DDevice_InsertCallback(this, Type, pCallback, Context); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetVerticalBlankCallback(__in_opt D3DVBLANKCALLBACK pCallback) { D3DDevice_SetVerticalBlankCallback(this, pCallback); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetSwapCallback(__in D3DSWAPCALLBACK pCallback) { D3DDevice_SetSwapCallback(this, pCallback); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::DrawTessellatedPrimitive(D3DTESSPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) { D3DDevice_DrawTessellatedVertices(this, PrimitiveType, StartVertex, D3DTESSVERTEXCOUNT(PrimitiveType, PrimitiveCount)); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::DrawIndexedTessellatedPrimitive(D3DTESSPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT StartIndex, UINT PrimitiveCount) { D3DDevice_DrawIndexedTessellatedVertices(this, PrimitiveType, BaseVertexIndex, StartIndex, D3DTESSVERTEXCOUNT(PrimitiveType, PrimitiveCount)); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::SetRingBufferParameters(__in_opt CONST D3DRING_BUFFER_PARAMETERS *pParameters) { return D3DDevice_SetRingBufferParameters(this, pParameters); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::XpsBegin(DWORD Flags) { D3DDevice_XpsBegin(this, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::XpsEnd() { return D3DDevice_XpsEnd(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::XpsSetCallback(__in D3DXpsCallback pCallback, __in_opt void* pContext, DWORD Flags) { D3DDevice_XpsSetCallback(this, pCallback, pContext, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::XpsSubmit(DWORD InstanceCount, __in_bcount(Size) CONST void* pData, DWORD Size) { D3DDevice_XpsSubmit(this, InstanceCount, pData, Size); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::XpsSetPredication(DWORD Predication) { D3DDevice_XpsSetPredication(this, Predication); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::XpsSetPredicationFromVisibility(HANDLE VisibilityHandle) { D3DDevice_XpsSetPredicationFromVisibility(this, VisibilityHandle); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::XpsSetPredicationFromQuery(__in_opt IDirect3DQuery9* pQuery) { D3DDevice_XpsSetPredicationFromQuery(this, pQuery); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::BeginVertices(D3DPRIMITIVETYPE PrimitiveType, UINT VertexCount, UINT VertexStreamZeroStride, __deref_out_bcount(VertexCount*VertexStreamZeroStride) void**ppVertexData) { return (*ppVertexData = D3DDevice_BeginVertices(this, PrimitiveType, VertexCount, VertexStreamZeroStride)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EndVertices() { D3DDevice_EndVertices(this); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::BeginIndexedVertices(D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT NumVertices, UINT IndexCount, D3DFORMAT IndexDataFormat, UINT VertexStreamZeroStride, __deref_out void** ppIndexData, __deref_out_bcount(NumVertices*VertexStreamZeroStride) void** ppVertexData) { return D3DDevice_BeginIndexedVertices(this, PrimitiveType, BaseVertexIndex, NumVertices, IndexCount, IndexDataFormat, VertexStreamZeroStride, ppIndexData, ppVertexData); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EndIndexedVertices() { D3DDevice_EndIndexedVertices(this); D3DVOIDRETURN; }
|
|
D3DMINLINE DWORD WINAPI D3DDevice::InsertFence() { return D3DDevice_InsertFence(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::BlockOnFence(DWORD Fence) { D3DDevice_BlockOnFence(Fence); D3DVOIDRETURN; }
|
|
D3DMINLINE BOOL WINAPI D3DDevice::IsFencePending(DWORD Fence) { return D3DDevice_IsFencePending(Fence); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetBlendState(DWORD RenderTargetIndex, D3DBLENDSTATE BlendState) { D3DDevice_SetBlendState(this, RenderTargetIndex, BlendState); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetBlendState(DWORD RenderTargetIndex, __out D3DBLENDSTATE* pBlendState) { D3DDevice_GetBlendState(this, RenderTargetIndex, pBlendState); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetVertexFetchConstant(UINT VertexFetchRegister, __in D3DVertexBuffer* pVertexBuffer, UINT Offset) { D3DDevice_SetVertexFetchConstant(this, VertexFetchRegister, pVertexBuffer, Offset); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetTextureFetchConstant(UINT TextureFetchRegister, __in D3DBaseTexture* pTexture) { D3DDevice_SetTextureFetchConstant(this, TextureFetchRegister, pTexture); D3DVOIDRETURN; }
|
|
D3DMINLINE float WINAPI D3DDevice::GetCounter(D3DCOUNTER CounterID) { return D3DDevice_GetCounter(this, CounterID);}
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetSafeLevel(DWORD Flags, DWORD Level) { D3DDevice_SetSafeLevel(this, Flags, Level); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetSafeLevel(DWORD* pFlags, __out DWORD* pLevel) { D3DDevice_GetSafeLevel(this, pFlags, pLevel); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetHangCallback(D3DHANGCALLBACK pCallback) { D3DDevice_SetHangCallback(this, pCallback); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::BeginConditionalSurvey(DWORD Identifier, DWORD Flags) { D3DDevice_BeginConditionalSurvey(this, Identifier, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EndConditionalSurvey(DWORD Flags) {D3DDevice_EndConditionalSurvey(this, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::BeginConditionalRendering(DWORD Identifier) { D3DDevice_BeginConditionalRendering(this, Identifier); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EndConditionalRendering() { D3DDevice_EndConditionalRendering(this); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::PersistDisplay(__in D3DTexture* pFrontBuffer, __in_opt CONST D3DVIDEO_SCALER_PARAMETERS* pParameters) { return D3DDevice_PersistDisplay(this, pFrontBuffer, pParameters); }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::GetPersistedTexture(__deref_out D3DTexture** pFrontBuffer) { return D3DDevice_GetPersistedTexture(this, pFrontBuffer); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::Suspend() { D3DDevice_Suspend(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::Resume() { D3DDevice_Resume(this); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreatePerfCounters(__deref_out D3DPerfCounters** ppCounters, UINT NumInstances) { return (*ppCounters = D3DDevice_CreatePerfCounters(this, NumInstances)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EnablePerfCounters(BOOL Enable) { D3DDevice_EnablePerfCounters(this, Enable); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetPerfCounterEvents(__in CONST D3DPERFCOUNTER_EVENTS* pEvents, DWORD Flags) { D3DDevice_SetPerfCounterEvents(this, pEvents, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::QueryPerfCounters(__in D3DPerfCounters* pCounters, DWORD Flags) { D3DDevice_QueryPerfCounters(this, pCounters, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE DWORD WINAPI D3DDevice::GetNumPasses() { return D3DDevice_GetNumPasses(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetShaderInstructionAllocation(DWORD Flags, DWORD VertexShaderBase, DWORD PixelShaderBase) { D3DDevice_SetShaderInstructionAllocation(this, Flags, VertexShaderBase, PixelShaderBase); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetShaderGPRAllocation(DWORD Flags, DWORD VertexShaderCount, DWORD PixelShaderCount) { D3DDevice_SetShaderGPRAllocation(this, Flags, VertexShaderCount, PixelShaderCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetShaderGPRAllocation(__out DWORD* pFlags, __out DWORD* pVertexShaderCount, __out DWORD* pPixelShaderCount) { D3DDevice_GetShaderGPRAllocation(this, pFlags, pVertexShaderCount, pPixelShaderCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetScreenExtentQueryMode(D3DSCREENEXTENTQUERYMODE Mode) { D3DDevice_SetScreenExtentQueryMode(this, Mode); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetScreenExtentQueryMode(__out D3DSCREENEXTENTQUERYMODE* pMode) { D3DDevice_GetScreenExtentQueryMode(this, pMode); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::BeginVertexShaderConstantF1(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, UINT Vector4fCount) { D3DDevice_BeginVertexShaderConstantF1(this, StartRegister, ppConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EndVertexShaderConstantF1() { D3DDevice_EndShaderConstantF1(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::BeginPixelShaderConstantF1(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, UINT Vector4fCount) { D3DDevice_BeginPixelShaderConstantF1(this, StartRegister, ppConstantData, Vector4fCount); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EndPixelShaderConstantF1() { D3DDevice_EndShaderConstantF1(this); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::BeginVertexShaderConstantF4(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppCachedConstantData, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppWriteCombinedConstantData, UINT Vector4fCount) { return D3DDevice_BeginShaderConstantF4(this, FALSE, StartRegister, ppCachedConstantData, ppWriteCombinedConstantData, Vector4fCount); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EndVertexShaderConstantF4() { D3DDevice_EndShaderConstantF4(this); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::BeginPixelShaderConstantF4(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppCachedConstantData, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppWriteCombinedConstantData, UINT Vector4fCount) { return D3DDevice_BeginShaderConstantF4(this, TRUE, StartRegister, ppCachedConstantData, ppWriteCombinedConstantData, Vector4fCount); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EndPixelShaderConstantF4() { D3DDevice_EndShaderConstantF4(this); D3DVOIDRETURN; }
|
|
D3DMINLINE DWORD WINAPI D3DDevice::GetCurrentFence() { return D3DDevice_GetCurrentFence(); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::InvalidateGpuCache(__in_bcount(Size) void* pBaseAddress, DWORD Size, DWORD Flags) { D3DDevice_InvalidateGpuCache(this, pBaseAddress, Size, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::InvalidateResourceGpuCache(__in D3DResource* pResource, DWORD Flags) { D3DDevice_InvalidateResourceGpuCache(this, pResource, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::FlushHiZStencil(D3DFHZS_FLUSHTYPE FlushType) { D3DDevice_FlushHiZStencil(this, FlushType); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::UnsetAll() { D3DDevice_UnsetAll(this); D3DVOIDRETURN; }
|
|
D3DMINLINE DWORD WINAPI D3DDevice::GetDeviceState() { return D3DDevice_GetDeviceState(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetBlockCallback(DWORD Flags, __in_opt D3DBLOCKCALLBACK pCallback) { D3DDevice_SetBlockCallback(this, Flags, pCallback); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetSurfaces(__in CONST D3DSURFACES* pSurfaces, DWORD Flags) { D3DDevice_SetSurfaces(this, pSurfaces, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::BeginCommandBuffer(__in D3DCommandBuffer* pCommandBuffer, DWORD Flags, __in_opt CONST D3DTAGCOLLECTION* pInheritTags, __in_opt CONST D3DTAGCOLLECTION* pPersistTags, __in_opt CONST D3DRECT* pTilingRects, DWORD TileCount) { D3DDevice_BeginCommandBuffer(this, pCommandBuffer, Flags, pInheritTags, pPersistTags, pTilingRects, TileCount); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::EndCommandBuffer() { return D3DDevice_EndCommandBuffer(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::RunCommandBuffer(__in D3DCommandBuffer* pCommandBuffer, DWORD PredicationSelect) { D3DDevice_RunCommandBuffer(this, pCommandBuffer, PredicationSelect); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::InsertAsyncCommandBufferCall(__in D3DAsyncCommandBufferCall* pAsyncCommandBufferCall, DWORD PredicationSelect, DWORD Flags) { return D3DDevice_InsertAsyncCommandBufferCall(this, pAsyncCommandBufferCall, PredicationSelect, Flags); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetCommandBufferPredication(DWORD TilePredication, DWORD RunPredication) { D3DDevice_SetCommandBufferPredication(this, TilePredication, RunPredication); D3DVOIDRETURN; }
|
|
D3DMINLINE DWORD WINAPI D3DDevice::InsertMarker() { return D3DDevice_InsertMarker(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::Nop(DWORD Count) { D3DDevice_Nop(this, Count); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::QuerySwapStatus(__out D3DSWAP_STATUS* pSwapStatus) { D3DDevice_QuerySwapStatus(this, pSwapStatus); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetViewportF(__in CONST D3DVIEWPORTF9* pViewportF) { D3DDevice_SetViewportF(this, pViewportF); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::GetViewportF(__out D3DVIEWPORTF9* pViewportF) { D3DDevice_GetViewportF(this, pViewportF); D3DVOIDRETURN; }
|
|
D3DMINLINE HANDLE WINAPI D3DDevice::BeginVisibilitySurvey(DWORD Flags) { return D3DDevice_BeginVisibilitySurvey(this, Flags); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::EndVisibilitySurvey(HANDLE VisibilityHandle) { D3DDevice_EndVisibilitySurvey(this, VisibilityHandle); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SetSwapMode(BOOL Asynchronous) { D3DDevice_SetSwapMode(this, Asynchronous); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DASYNCBLOCK WINAPI D3DDevice::InsertBlockOnAsyncResources(DWORD WriteCount, __in_ecount_opt(WriteCount) D3DResource* CONST* pWriteResourceList, DWORD ReadCount, __in_ecount_opt(ReadCount) D3DResource* CONST* pReadResourceList, DWORD Flags) { return D3DDevice_InsertBlockOnAsyncResources(this, WriteCount, pWriteResourceList, ReadCount, pReadResourceList, Flags); }
|
|
D3DMINLINE D3DVOID WINAPI D3DDevice::SignalAsyncResources(D3DASYNCBLOCK AsyncBlock) { D3DDevice_SignalAsyncResources(this, AsyncBlock); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateAsyncCommandBufferCall(D3DTAGCOLLECTION* pInheritTags, D3DTAGCOLLECTION* pPersistTags, DWORD NumSegments, DWORD Flags, D3DAsyncCommandBufferCall** ppAsyncCall ) { return (*ppAsyncCall = D3DDevice_CreateAsyncCommandBufferCall(this, pInheritTags, pPersistTags, NumSegments, Flags)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreatePerfCounterBatch(UINT NumSlots, UINT NumTiles, DWORD Flags, __deref_out D3DPerfCounterBatch** ppBatch) { return (*ppBatch = D3DDevice_CreatePerfCounterBatch(this, NumSlots, NumTiles, Flags)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::CreateOcclusionQueryBatch(UINT NumSlots, UINT NumTiles, __deref_out D3DOcclusionQueryBatch** ppBatch) { return (*ppBatch = D3DDevice_CreateOcclusionQueryBatch(this, NumSlots, NumTiles)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
|
|
D3DMINLINE void WINAPI D3DDevice::GpuOwn(D3DTAG Tag) { D3DDevice_GpuOwn(this, Tag); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuOwnSubset(D3DTAG Tag, DWORD StartIndex, DWORD EndIndex) { D3DDevice_GpuOwnSubset(this, Tag, StartIndex, EndIndex); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuOwnVertexShaderConstantF(DWORD StartRegister, DWORD Vector4fCount) { D3DDevice_GpuOwnVertexShaderConstantF(this, StartRegister, Vector4fCount); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuOwnPixelShaderConstantF(DWORD StartRegister, DWORD Vector4fCount) { D3DDevice_GpuOwnPixelShaderConstantF(this, StartRegister, Vector4fCount); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuOwnShaders() { D3DDevice_GpuOwnShaders(this); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuDisown(D3DTAG Tag) { D3DDevice_GpuDisown(this, Tag); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuDisownSubset(D3DTAG Tag, DWORD StartIndex, DWORD EndIndex) { D3DDevice_GpuDisownSubset(this, Tag, StartIndex, EndIndex); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuDisownVertexShaderConstantF(DWORD StartRegister, DWORD Vector4fCount) { D3DDevice_GpuDisownVertexShaderConstantF(this, StartRegister, Vector4fCount); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuDisownPixelShaderConstantF(DWORD StartRegister, DWORD Vector4fCount) { D3DDevice_GpuDisownPixelShaderConstantF(this, StartRegister, Vector4fCount); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuDisownShaders() { D3DDevice_GpuDisownShaders(this); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuDisownAll() { D3DDevice_GpuDisownAll(this); }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::GpuBeginVertexShaderConstantF4(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, DWORD Vector4fCount) { return (*ppConstantData = D3DDevice_GpuBeginShaderConstantF4(this, FALSE, StartRegister, Vector4fCount)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuEndVertexShaderConstantF4() { D3DDevice_GpuEndShaderConstantF4(this); }
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::GpuBeginPixelShaderConstantF4(UINT StartRegister, __deref_out_ecount(Vector4fCount) D3DVECTOR4** ppConstantData, DWORD Vector4fCount) { return (*ppConstantData = D3DDevice_GpuBeginShaderConstantF4(this, TRUE, StartRegister, Vector4fCount)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuEndPixelShaderConstantF4() { D3DDevice_GpuEndShaderConstantF4(this); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuLoadVertexShaderConstantF4(UINT StartRegister, DWORD Vector4fCount, __in D3DConstantBuffer* pConstantBuffer, DWORD OffsetInVectors) { D3DDevice_GpuLoadShaderConstantF4(this, FALSE, StartRegister, Vector4fCount, pConstantBuffer, OffsetInVectors); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuLoadPixelShaderConstantF4(UINT StartRegister, DWORD Vector4fCount, __in D3DConstantBuffer* pConstantBuffer, DWORD OffsetInVectors) { D3DDevice_GpuLoadShaderConstantF4(this, TRUE, StartRegister, Vector4fCount, pConstantBuffer, OffsetInVectors); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuLoadVertexShaderConstantF4Pointer(UINT StartRegister, __in_bcount(4*sizeof(FLOAT)*Vector4fCount) CONST void* pConstantData, DWORD Vector4fCount) { D3DDevice_GpuLoadShaderConstantF4Pointer(this, FALSE, StartRegister, pConstantData, Vector4fCount); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuLoadPixelShaderConstantF4Pointer(UINT StartRegister, __in_bcount(4*sizeof(FLOAT)*Vector4fCount) CONST void* pConstantData, DWORD Vector4fCount) { D3DDevice_GpuLoadShaderConstantF4Pointer(this, TRUE, StartRegister, pConstantData, Vector4fCount); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuLoadShaders(__in D3DVertexShader* pVertexShader, __in_opt D3DPixelShader* pPixelShader, __in_opt CONST GPUFLOW_CONSTANTS* pFlowConstants) { D3DDevice_GpuLoadShaders(this, pVertexShader, pPixelShader, pFlowConstants); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuLoadShadersFast(__in D3DVertexShader* pVertexShader, __in_opt D3DPixelShader* pPixelShader, __in_opt CONST GPUFLOW_CONSTANTS* pFlowConstants, DWORD Flags) { D3DDevice_GpuLoadShadersFast(this, pVertexShader, pPixelShader, pFlowConstants, Flags); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuSetVertexFetchConstant(DWORD VertexFetchRegister, __in_opt D3DVertexBuffer* pVertexBuffer0, DWORD OffsetInBytes0, __in_opt D3DVertexBuffer* pVertexBuffer1, DWORD OffsetInBytes1, __in_opt D3DVertexBuffer* pVertexBuffer2, DWORD OffsetInBytes2) { D3DDevice_GpuSetVertexFetchConstant(this, VertexFetchRegister, pVertexBuffer0, OffsetInBytes0, pVertexBuffer1, OffsetInBytes1, pVertexBuffer2, OffsetInBytes2); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuSetTextureFetchConstant(DWORD TextureFetchRegister, __in D3DBaseTexture* pTexture) { D3DDevice_GpuSetTextureFetchConstant(this, TextureFetchRegister, pTexture); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuSetColorMask(__in const GPU_COLORMASK* pColorMask) { D3DDevice_GpuSetColorMask(this, pColorMask->dword); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuSetBlendFactor(__in const D3DCOLORVALUE* pColor) { D3DDevice_GpuSetBlendFactor(this, pColor->r, pColor->g, pColor->b, pColor->a); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuSetAlphaRef(float Ref) { D3DDevice_GpuSetAlphaRef(this, Ref); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuSetBlendControl(DWORD RenderTargetIndex, __in const GPU_BLENDCONTROL* pBlendControl) { D3DDevice_GpuSetBlendControl(this, RenderTargetIndex, pBlendControl->dword); }
|
|
D3DMINLINE void WINAPI D3DDevice::GpuSetColorControl(__in const GPU_COLORCONTROL* pColorControl) { D3DDevice_GpuSetColorControl(this, pColorControl->dword); }
|
|
|
|
// Make the PIX methods disappear on retail builds
|
|
//
|
|
D3DMINLINE DWORD WINAPI D3DDevice::PixBeginNamedEvent(DWORD Color, __in_z CONST char *szName, ...)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS)
|
|
va_list arglist;
|
|
va_start(arglist, szName);
|
|
return D3DDevice_PixBeginNamedEvent(this, Color, szName, arglist);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
D3DMINLINE DWORD WINAPI D3DDevice::PixEndNamedEvent()
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS)
|
|
return D3DDevice_PixEndNamedEvent(this);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
D3DMINLINE void WINAPI D3DDevice::PixSetMarker(DWORD Color, __in_z CONST char *szName, ...)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS)
|
|
va_list arglist;
|
|
va_start(arglist, szName);
|
|
D3DDevice_PixSetMarker(this, Color, szName, arglist);
|
|
#endif
|
|
}
|
|
|
|
// Make the PIX Texture Tracking methods disappear on retail and x86 builds
|
|
//
|
|
D3DMINLINE void WINAPI D3DDevice::PixIgnoreTexture(__in D3DBaseTexture* pTexture)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixIgnoreTexture(this, pTexture);
|
|
#endif
|
|
}
|
|
|
|
D3DMINLINE void WINAPI D3DDevice::PixStopIgnoringTexture(__in D3DBaseTexture* pTexture)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixStopIgnoringTexture(this, pTexture);
|
|
#endif
|
|
}
|
|
|
|
D3DMINLINE void WINAPI D3DDevice::PixIgnoreMemoryRange(__in_bcount(Size) const void* pBaseAddress, DWORD Size)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixIgnoreMemoryRange(this, pBaseAddress, Size);
|
|
#endif
|
|
}
|
|
|
|
D3DMINLINE void WINAPI D3DDevice::PixStopIgnoringMemoryRange(__in_bcount(Size) const void* pBaseAddress, DWORD Size)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixStopIgnoringMemoryRange(this, pBaseAddress, Size);
|
|
#endif
|
|
}
|
|
|
|
D3DMINLINE HRESULT WINAPI D3DDevice::PixSetTextureName(__in D3DBaseTexture* pTexture, __in_z const char* pName)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
return D3DDevice_PixSetTextureName(this, pTexture, pName);
|
|
#else
|
|
return S_OK;
|
|
#endif
|
|
}
|
|
|
|
D3DMINLINE void WINAPI D3DDevice::PixReportNewTexture(__in D3DBaseTexture* pTexture)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixReportNewTexture(this, pTexture);
|
|
#endif
|
|
}
|
|
|
|
D3DMINLINE void WINAPI D3DDevice::PixReportDeletedTexture(__in D3DBaseTexture* pTexture, BOOL BaseDeleted, BOOL MipDeleted)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixReportDeletedTexture(this, pTexture, BaseDeleted, MipDeleted);
|
|
#endif
|
|
}
|
|
|
|
D3DMINLINE void WINAPI D3DDevice::PixReportMovedMemoryRange(__in_bcount(Size) const void* pDestinationAddress, __in_bcount(Size) const void* pSourceAddress, DWORD Size)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixReportMovedMemoryRange(this, pDestinationAddress, pSourceAddress, Size);
|
|
#endif
|
|
}
|
|
|
|
D3DMINLINE void WINAPI D3DDevice::PixReportFreedMemoryRange(__in_bcount(Size) const void* pAddress, DWORD Size)
|
|
{
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
D3DDevice_PixReportFreedMemoryRange(this, pAddress, Size);
|
|
#endif
|
|
}
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DPerfCounters */
|
|
|
|
ULONG WINAPI D3DPerfCounters_AddRef(__in D3DPerfCounters *pThis);
|
|
ULONG WINAPI D3DPerfCounters_Release(__in D3DPerfCounters *pThis);
|
|
void WINAPI D3DPerfCounters_GetDevice(__in D3DPerfCounters *pThis, __deref_out D3DDevice **ppDevice);
|
|
BOOL WINAPI D3DPerfCounters_IsBusy(__in D3DPerfCounters *pThis);
|
|
void WINAPI D3DPerfCounters_BlockUntilNotBusy(__in D3DPerfCounters *pThis);
|
|
UINT WINAPI D3DPerfCounters_GetNumPasses(__in D3DPerfCounters* pThis);
|
|
HRESULT WINAPI D3DPerfCounters_GetValues(__in D3DPerfCounters *pThis, __out D3DPERFCOUNTER_VALUES* pValues, UINT PassIndex, __out_opt DWORD* pPassType);
|
|
|
|
// Compatibility wrappers.
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DPerfCounters9_AddRef(__in D3DPerfCounters *pThis) { return D3DPerfCounters_AddRef(pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DPerfCounters9_Release(__in D3DPerfCounters *pThis) { return D3DPerfCounters_Release(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DPerfCounters9_GetDevice(__in D3DPerfCounters *pThis, __deref_out D3DDevice **ppDevice) { D3DPerfCounters_GetDevice(pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE BOOL WINAPI IDirect3DPerfCounters9_IsBusy(__in D3DPerfCounters *pThis) { return D3DPerfCounters_IsBusy(pThis); }
|
|
D3DINLINE void WINAPI IDirect3DPerfCounters9_BlockUntilNotBusy(__in D3DPerfCounters *pThis) { D3DPerfCounters_BlockUntilNotBusy(pThis); }
|
|
D3DINLINE UINT WINAPI IDirect3DPerfCounters9_GetNumPasses(__in D3DPerfCounters* pThis) { return D3DPerfCounters_GetNumPasses(pThis); }
|
|
D3DINLINE HRESULT WINAPI IDirect3DPerfCounters9_GetValues(__in D3DPerfCounters *pThis, __out D3DPERFCOUNTER_VALUES* pValues, UINT PassIndex, __out_opt DWORD* pPassType) { return D3DPerfCounters_GetValues(pThis, pValues, PassIndex, pPassType); }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE ULONG WINAPI D3DPerfCounters::AddRef() { return D3DPerfCounters_AddRef(this); }
|
|
D3DMINLINE ULONG WINAPI D3DPerfCounters::Release() { return D3DPerfCounters_Release(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DPerfCounters::GetDevice(__deref_out D3DDevice **ppDevice) { D3DPerfCounters_GetDevice(this, ppDevice); D3DVOIDRETURN; }
|
|
D3DMINLINE BOOL WINAPI D3DPerfCounters::IsBusy() { return D3DPerfCounters_IsBusy(this); }
|
|
D3DMINLINE void WINAPI D3DPerfCounters::BlockUntilNotBusy() { D3DPerfCounters_BlockUntilNotBusy(this); }
|
|
D3DMINLINE UINT WINAPI D3DPerfCounters::GetNumPasses() {return D3DPerfCounters_GetNumPasses(this); }
|
|
D3DMINLINE HRESULT WINAPI D3DPerfCounters::GetValues(__out D3DPERFCOUNTER_VALUES* pValues, UINT InstanceIndex, __out DWORD* pMask) { return D3DPerfCounters_GetValues(this, pValues, InstanceIndex, pMask); }
|
|
|
|
#endif
|
|
|
|
/* D3DPerfCounterBatch */
|
|
|
|
void WINAPI D3DPerfCounterBatch_Reset(__in D3DPerfCounterBatch *pThis);
|
|
UINT WINAPI D3DPerfCounterBatch_Issue(__in D3DPerfCounterBatch *pThis, DWORD PerfCounterIndex, DWORD Flags);
|
|
__out void* WINAPI D3DPerfCounterBatch_Lock(__in D3DPerfCounterBatch *pThis);
|
|
void WINAPI D3DPerfCounterBatch_Unlock(__in D3DPerfCounterBatch *pThis);
|
|
void WINAPI D3DPerfCounterBatch_ValidateSlot(__in D3DPerfCounterBatch *pThis, DWORD Slot, DWORD Flags);
|
|
|
|
D3DMINLINE UINT WINAPI D3DPerfCounterBatch_GetNumSlotsUsed(__in D3DPerfCounterBatch *pThis)
|
|
{
|
|
return pThis->m_SlotsUsed;
|
|
}
|
|
|
|
D3DMINLINE UINT WINAPI D3DPerfCounterBatch_GetValue32(__in D3DPerfCounterBatch *pThis, DWORD Slot)
|
|
{
|
|
UINT sum = 0;
|
|
UINT passes = pThis->m_NumPasses;
|
|
UINT* pData = (UINT*)(pThis->m_pCachedReadOnlyBase + Slot * pThis->m_SlotSize);
|
|
|
|
#if defined(_DEBUG)
|
|
D3DPerfCounterBatch_ValidateSlot(pThis, Slot, 0);
|
|
#endif
|
|
|
|
for(; passes != 0; --passes, ++pData)
|
|
{
|
|
sum += *pData;
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
D3DMINLINE UINT64 WINAPI D3DPerfCounterBatch_GetValue64(__in D3DPerfCounterBatch *pThis, DWORD Slot)
|
|
{
|
|
UINT64 sum = 0;
|
|
UINT passes = pThis->m_NumPasses;
|
|
UINT64* pData = (UINT64*)(pThis->m_pCachedReadOnlyBase + Slot * pThis->m_SlotSize);
|
|
|
|
#if defined(_DEBUG)
|
|
D3DPerfCounterBatch_ValidateSlot(pThis, Slot, D3DPERFCOUNTERBATCH_64BIT);
|
|
#endif
|
|
|
|
for(; passes != 0; --passes, ++pData)
|
|
{
|
|
sum += *pData;
|
|
}
|
|
return sum;
|
|
}
|
|
|
|
// Compatibility wrappers.
|
|
|
|
D3DINLINE void WINAPI IDirect3DPerfCounterBatch9_Reset(__in D3DPerfCounterBatch *pThis) { D3DPerfCounterBatch_Reset(pThis); }
|
|
D3DINLINE UINT WINAPI IDirect3DPerfCounterBatch9_Issue(__in D3DPerfCounterBatch *pThis, DWORD PerfCounterIndex, DWORD Flags) { return D3DPerfCounterBatch_Issue(pThis, PerfCounterIndex, Flags); }
|
|
D3DINLINE UINT WINAPI IDirect3DPerfCounterBatch9_GetNumSlotsUsed(__in D3DPerfCounterBatch* pThis) { return D3DPerfCounterBatch_GetNumSlotsUsed(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DPerfCounterBatch9_Lock(__in D3DPerfCounterBatch *pThis, __deref_out void** ppData) { *ppData = D3DPerfCounterBatch_Lock(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DPerfCounterBatch9_Unlock(__in D3DPerfCounterBatch *pThis) { D3DPerfCounterBatch_Unlock(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE UINT WINAPI IDirect3DPerfCounterBatch9_GetValue32(__in D3DPerfCounterBatch *pThis, DWORD Slot) { return D3DPerfCounterBatch_GetValue32(pThis, Slot); }
|
|
D3DINLINE UINT64 WINAPI IDirect3DPerfCounterBatch9_GetValue64(__in D3DPerfCounterBatch *pThis, DWORD Slot) { return D3DPerfCounterBatch_GetValue64(pThis, Slot); }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE void WINAPI D3DPerfCounterBatch::Reset() { D3DPerfCounterBatch_Reset(this); }
|
|
D3DMINLINE UINT WINAPI D3DPerfCounterBatch::Issue(DWORD PerfCounterIndex, DWORD Flags) { return D3DPerfCounterBatch_Issue(this, PerfCounterIndex, Flags); }
|
|
D3DMINLINE UINT WINAPI D3DPerfCounterBatch::GetNumSlotsUsed() { return D3DPerfCounterBatch_GetNumSlotsUsed(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DPerfCounterBatch::Lock(__deref_out void** ppData) { *ppData = D3DPerfCounterBatch_Lock(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DPerfCounterBatch::Unlock() { D3DPerfCounterBatch_Unlock(this); D3DVOIDRETURN; }
|
|
D3DMINLINE UINT WINAPI D3DPerfCounterBatch::GetValue32(DWORD Slot) { return D3DPerfCounterBatch_GetValue32(this, Slot); }
|
|
D3DMINLINE UINT64 WINAPI D3DPerfCounterBatch::GetValue64(DWORD Slot) { return D3DPerfCounterBatch_GetValue64(this, Slot); }
|
|
|
|
#endif
|
|
|
|
/* D3DOcclusionQueryBatch */
|
|
|
|
void WINAPI D3DOcclusionQueryBatch_Reset(__in D3DOcclusionQueryBatch *pThis);
|
|
UINT WINAPI D3DOcclusionQueryBatch_Issue(__in D3DOcclusionQueryBatch *pThis);
|
|
__out void* WINAPI D3DOcclusionQueryBatch_Lock(__in D3DOcclusionQueryBatch *pThis);
|
|
void WINAPI D3DOcclusionQueryBatch_Unlock(__in D3DOcclusionQueryBatch *pThis);
|
|
void WINAPI D3DOcclusionQueryBatch_ValidateSlot(__in D3DOcclusionQueryBatch *pThis, DWORD Slot);
|
|
|
|
D3DMINLINE UINT WINAPI D3DOcclusionQueryBatch_GetNumSlotsUsed(__in D3DOcclusionQueryBatch *pThis)
|
|
{
|
|
return pThis->m_SlotsUsed;
|
|
}
|
|
|
|
D3DMINLINE void WINAPI D3DOcclusionQueryBatch_GetOcclusionStats(__in D3DOcclusionQueryBatch *pThis, DWORD Slot, __out D3DOCCLUSIONSTATS* pOcclusionStats)
|
|
{
|
|
UINT passes = pThis->m_NumTiles;
|
|
GPU_SAMPLECOUNT* pData = (GPU_SAMPLECOUNT*)(pThis->m_pCachedReadOnlyBase + Slot * pThis->m_SlotSize);
|
|
|
|
#if defined(_DEBUG)
|
|
D3DOcclusionQueryBatch_ValidateSlot(pThis, Slot);
|
|
#endif
|
|
|
|
memset(pOcclusionStats, 0, sizeof(D3DOCCLUSIONSTATS));
|
|
|
|
for(; passes != 0; --passes, ++pData)
|
|
{
|
|
pOcclusionStats->Total += _byteswap_ulong(pData->Total[0]) + _byteswap_ulong(pData->Total[1]);
|
|
pOcclusionStats->ZPass += _byteswap_ulong(pData->ZPass[0]) + _byteswap_ulong(pData->ZPass[1]);
|
|
pOcclusionStats->ZFail += _byteswap_ulong(pData->ZFail[0]) + _byteswap_ulong(pData->ZFail[1]);
|
|
pOcclusionStats->StencilFail += _byteswap_ulong(pData->StencilFail[0]) + _byteswap_ulong(pData->StencilFail[1]);
|
|
}
|
|
}
|
|
|
|
D3DMINLINE UINT WINAPI D3DOcclusionQueryBatch_GetPixelCount(__in D3DOcclusionQueryBatch *pThis, DWORD Slot)
|
|
{
|
|
UINT passes = pThis->m_NumTiles;
|
|
UINT pixelCount = 0;
|
|
GPU_SAMPLECOUNT* pData = (GPU_SAMPLECOUNT*)(pThis->m_pCachedReadOnlyBase + Slot * pThis->m_SlotSize);
|
|
|
|
#if defined(_DEBUG)
|
|
D3DOcclusionQueryBatch_ValidateSlot(pThis, Slot);
|
|
#endif
|
|
|
|
for(; passes != 0; --passes, ++pData)
|
|
{
|
|
pixelCount += _byteswap_ulong(pData->ZPass[0]) + _byteswap_ulong(pData->ZPass[1]);
|
|
}
|
|
return pixelCount;
|
|
}
|
|
|
|
// Compatibility wrappers.
|
|
|
|
D3DINLINE void WINAPI IDirect3DOcclusionQueryBatch9_Reset(__in D3DOcclusionQueryBatch *pThis) { D3DOcclusionQueryBatch_Reset(pThis); }
|
|
D3DINLINE UINT WINAPI IDirect3DOcclusionQueryBatch9_Issue(__in D3DOcclusionQueryBatch *pThis) { return D3DOcclusionQueryBatch_Issue(pThis); }
|
|
D3DINLINE UINT WINAPI IDirect3DOcclusionQueryBatch9_GetNumSlotsUsed(__in D3DOcclusionQueryBatch *pThis) { D3DOcclusionQueryBatch_GetNumSlotsUsed(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DOcclusionQueryBatch9_Lock(__in D3DOcclusionQueryBatch *pThis, __deref_out void** ppData) { *ppData = D3DOcclusionQueryBatch_Lock(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DOcclusionQueryBatch9_Unlock(__in D3DOcclusionQueryBatch *pThis) { D3DOcclusionQueryBatch_Unlock(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE void WINAPI IDirect3DOcclusionQueryBatch9_GetOcclusionStats(__in D3DOcclusionQueryBatch* pThis, DWORD Slot, __out D3DOCCLUSIONSTATS* pOcclusionStats) { D3DOcclusionQueryBatch_GetOcclusionStats(pThis, Slot, pOcclusionStats); }
|
|
D3DINLINE UINT WINAPI IDirect3DOcclusionQueryBatch9_GetPixelCount(__in D3DOcclusionQueryBatch* pThis, DWORD Slot) { return D3DOcclusionQueryBatch_GetPixelCount(pThis, Slot); }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE void WINAPI D3DOcclusionQueryBatch::Reset() { D3DOcclusionQueryBatch_Reset(this); }
|
|
D3DMINLINE UINT WINAPI D3DOcclusionQueryBatch::Issue() { return D3DOcclusionQueryBatch_Issue(this); }
|
|
D3DMINLINE UINT WINAPI D3DOcclusionQueryBatch::GetNumSlotsUsed() { return D3DOcclusionQueryBatch_GetNumSlotsUsed(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DOcclusionQueryBatch::Lock(__deref_out void** ppData) { *ppData = D3DOcclusionQueryBatch_Lock(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DOcclusionQueryBatch::Unlock() { D3DOcclusionQueryBatch_Unlock(this); D3DVOIDRETURN; }
|
|
D3DMINLINE void WINAPI D3DOcclusionQueryBatch::GetOcclusionStats(DWORD Slot, __out D3DOCCLUSIONSTATS* pOcclusionStats) { D3DOcclusionQueryBatch_GetOcclusionStats(this, Slot, pOcclusionStats); }
|
|
D3DMINLINE UINT WINAPI D3DOcclusionQueryBatch::GetPixelCount(DWORD Slot) { return D3DOcclusionQueryBatch_GetPixelCount(this, Slot); }
|
|
|
|
#endif
|
|
|
|
/* D3DQuery */
|
|
|
|
ULONG WINAPI D3DQuery_AddRef(__in D3DQuery *pThis);
|
|
ULONG WINAPI D3DQuery_Release(__in D3DQuery *pThis);
|
|
void WINAPI D3DQuery_GetDevice(__in D3DQuery *pThis, __deref_out D3DDevice **ppDevice);
|
|
D3DQUERYTYPE WINAPI D3DQuery_GetType(__in D3DQuery *pThis);
|
|
DWORD WINAPI D3DQuery_GetDataSize(__in D3DQuery *pThis);
|
|
void WINAPI D3DQuery_Issue(__in D3DQuery *pThis, DWORD IssueFlags);
|
|
HRESULT WINAPI D3DQuery_GetData(__in D3DQuery *pThis, __out_bcount(Size) void* pData, DWORD Size, DWORD GetDataFlags);
|
|
|
|
// Compatibility wrappers.
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DQuery9_AddRef(__in D3DQuery *pThis) { return D3DQuery_AddRef(pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DQuery9_Release(__in D3DQuery *pThis) { return D3DQuery_Release(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DQuery9_GetDevice(__in D3DQuery *pThis, __deref_out D3DDevice **ppDevice) { D3DQuery_GetDevice(pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DQUERYTYPE WINAPI IDirect3DQuery9_GetType(__in D3DQuery *pThis) { return D3DQuery_GetType(pThis); }
|
|
D3DINLINE DWORD WINAPI IDirect3DQuery9_GetDataSize(__in D3DQuery *pThis) { return D3DQuery_GetDataSize(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DQuery9_Issue(__in D3DQuery *pThis, DWORD IssueFlags) { D3DQuery_Issue(pThis, IssueFlags); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DQuery9_GetData(__in D3DQuery *pThis, __out_bcount(Size) void* pData, DWORD Size, DWORD GetDataFlags) { return D3DQuery_GetData(pThis, pData, Size, GetDataFlags); }
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE ULONG WINAPI D3DQuery::AddRef() { return D3DQuery_AddRef(this); }
|
|
D3DMINLINE ULONG WINAPI D3DQuery::Release() { return D3DQuery_Release(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DQuery::GetDevice(__deref_out D3DDevice **ppDevice) { D3DQuery_GetDevice(this, ppDevice); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DQUERYTYPE WINAPI D3DQuery::GetType() { return D3DQuery_GetType(this); }
|
|
D3DMINLINE DWORD WINAPI D3DQuery::GetDataSize() { return D3DQuery_GetDataSize(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DQuery::Issue(DWORD IssueFlags) { D3DQuery_Issue(this, IssueFlags); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DQuery::GetData(__out_bcount(Size) void* pData, DWORD Size, DWORD GetDataFlags) { return D3DQuery_GetData(this, pData, Size, GetDataFlags); }
|
|
|
|
#endif
|
|
|
|
/* D3DStateBlock */
|
|
|
|
ULONG WINAPI D3DStateBlock_AddRef(__in D3DStateBlock *pThis);
|
|
ULONG WINAPI D3DStateBlock_Release(__in D3DStateBlock *pThis);
|
|
void WINAPI D3DStateBlock_GetDevice(__in D3DStateBlock *pThis, __deref_out D3DDevice **ppDevice);
|
|
void WINAPI D3DStateBlock_Capture(__in D3DStateBlock *pThis);
|
|
void WINAPI D3DStateBlock_Apply(__in D3DStateBlock *pThis);
|
|
|
|
// Compatibility wrappers.
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DStateBlock9_AddRef(__in D3DStateBlock *pThis) { return D3DStateBlock_AddRef(pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DStateBlock9_Release(__in D3DStateBlock *pThis) { return D3DStateBlock_Release(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DStateBlock9_GetDevice(__in D3DStateBlock *pThis, __deref_out D3DDevice **ppDevice) { D3DStateBlock_GetDevice(pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DStateBlock9_Capture(__in D3DStateBlock *pThis) { D3DStateBlock_Capture(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DStateBlock9_Apply(__in D3DStateBlock *pThis) { D3DStateBlock_Apply(pThis); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE ULONG WINAPI D3DStateBlock::AddRef() { return D3DStateBlock_AddRef(this); }
|
|
D3DMINLINE ULONG WINAPI D3DStateBlock::Release() { return D3DStateBlock_Release(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DStateBlock::GetDevice(__deref_out D3DDevice **ppDevice) { D3DStateBlock_GetDevice(this, ppDevice); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DStateBlock::Capture() { D3DStateBlock_Capture(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DStateBlock::Apply() { D3DStateBlock_Apply(this); D3DVOIDRETURN; }
|
|
|
|
#endif
|
|
|
|
/* D3DResource */
|
|
|
|
ULONG WINAPI D3DResource_AddRef(__in D3DResource *pThis);
|
|
ULONG WINAPI D3DResource_Release(__in D3DResource *pThis);
|
|
void WINAPI D3DResource_GetDevice(__in D3DResource *pThis, __deref_out D3DDevice **ppDevice);
|
|
D3DRESOURCETYPE WINAPI D3DResource_GetType(__in D3DResource *pThis);
|
|
BOOL WINAPI D3DResource_IsBusy(__in D3DResource *pThis);
|
|
BOOL WINAPI D3DResource_IsSet(__in D3DResource *pThis, __in D3DDevice *pDevice);
|
|
void WINAPI D3DResource_BlockUntilNotBusy(__in D3DResource *pThis);
|
|
|
|
D3DINLINE void WINAPI D3DResource_SetIdentifier(__in D3DResource *pThis, DWORD Identifier) { pThis->Identifier = Identifier; }
|
|
D3DINLINE DWORD WINAPI D3DResource_GetIdentifier(__in D3DResource *pThis) { return pThis->Identifier; }
|
|
|
|
// Compatibility wrappers.
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DResource9_AddRef(__in D3DResource *pThis) { return D3DResource_AddRef(pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DResource9_Release(__in D3DResource *pThis) { return D3DResource_Release(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DResource9_GetDevice(__in D3DResource *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice(pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DResource9_GetType(__in D3DResource *pThis) { return D3DResource_GetType(pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DResource9_IsBusy(__in D3DResource *pThis) { return D3DResource_IsBusy(pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DResource9_IsSet(__in D3DResource *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet(pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DResource9_BlockUntilNotBusy(__in D3DResource *pThis) { D3DResource_BlockUntilNotBusy(pThis); }
|
|
D3DINLINE void WINAPI IDirect3DResource9_SetIdentifier(__in D3DResource *pThis, DWORD Identifier) { D3DResource_SetIdentifier(pThis, Identifier); }
|
|
D3DINLINE DWORD WINAPI IDirect3DResource9_GetIdentifier(__in D3DResource *pThis) { return D3DResource_GetIdentifier(pThis); }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE ULONG WINAPI D3DResource::AddRef() { return D3DResource_AddRef(this); }
|
|
D3DMINLINE ULONG WINAPI D3DResource::Release() { return D3DResource_Release(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DResource::GetDevice(__deref_out D3DDevice **ppDevice) { D3DResource_GetDevice(this, ppDevice); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DRESOURCETYPE WINAPI D3DResource::GetType() { return D3DResource_GetType(this); }
|
|
D3DMINLINE BOOL WINAPI D3DResource::IsBusy() { return D3DResource_IsBusy(this); }
|
|
D3DMINLINE BOOL WINAPI D3DResource::IsSet(__in D3DDevice *pDevice) { return D3DResource_IsSet(this, pDevice); }
|
|
D3DMINLINE void WINAPI D3DResource::BlockUntilNotBusy() { D3DResource_BlockUntilNotBusy(this); }
|
|
D3DMINLINE void WINAPI D3DResource::SetIdentifier(DWORD Identifier) { D3DResource_SetIdentifier(this, Identifier); }
|
|
D3DMINLINE DWORD WINAPI D3DResource::GetIdentifier() { return D3DResource_GetIdentifier(this); }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DBaseTexture */
|
|
|
|
D3DINLINE ULONG WINAPI D3DBaseTexture_AddRef(__in D3DBaseTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DBaseTexture_Release(__in D3DBaseTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DBaseTexture_GetDevice(__in D3DBaseTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DBaseTexture_GetType(__in D3DBaseTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DBaseTexture_IsBusy(__in D3DBaseTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DBaseTexture_IsSet(__in D3DBaseTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DBaseTexture_BlockUntilNotBusy(__in D3DBaseTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
DWORD WINAPI D3DBaseTexture_GetLevelCount(__in D3DBaseTexture *pThis);
|
|
void WINAPI D3DBaseTexture_GetTailDesc(__in D3DBaseTexture *pThis, __out D3DMIPTAIL_DESC *pDesc);
|
|
void WINAPI D3DBaseTexture_LockTail(__in D3DBaseTexture *pThis, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
void WINAPI D3DBaseTexture_AsyncLockTail(__in D3DBaseTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags);
|
|
void WINAPI D3DBaseTexture_UnlockTail(__in D3DBaseTexture *pThis, UINT ArrayIndex);
|
|
|
|
// Compatibility wrappers.
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DBaseTexture9_AddRef(__in D3DBaseTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DBaseTexture9_Release(__in D3DBaseTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DBaseTexture9_GetDevice(__in D3DBaseTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DBaseTexture9_GetType(__in D3DBaseTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DBaseTexture9_IsBusy(__in D3DBaseTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DBaseTexture9_IsSet(__in D3DBaseTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DBaseTexture9_BlockUntilNotBusy(__in D3DBaseTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE DWORD WINAPI IDirect3DBaseTexture9_GetLevelCount(__in D3DBaseTexture *pThis) { return D3DBaseTexture_GetLevelCount(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DBaseTexture9_GetTailDesc(__in D3DBaseTexture *pThis, __out D3DMIPTAIL_DESC *pDesc) { D3DBaseTexture_GetTailDesc(pThis, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DBaseTexture9_LockTail(__in D3DBaseTexture *pThis, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_LockTail(pThis, ArrayIndex, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DBaseTexture9_AsyncLockTail(__in D3DBaseTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_AsyncLockTail(pThis, AsyncBlock, ArrayIndex, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DBaseTexture9_UnlockTail(__in D3DBaseTexture *pThis, UINT ArrayIndex) { D3DBaseTexture_UnlockTail(pThis, ArrayIndex); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE DWORD WINAPI D3DBaseTexture::GetLevelCount() { return D3DBaseTexture_GetLevelCount(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DBaseTexture::GetTailDesc(__out D3DMIPTAIL_DESC *pDesc) { D3DBaseTexture_GetTailDesc(this, pDesc); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DBaseTexture::LockTail(UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_LockTail(this, ArrayIndex, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DBaseTexture::AsyncLockTail(D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_AsyncLockTail(this, AsyncBlock, ArrayIndex, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DBaseTexture::UnlockTail(UINT ArrayIndex) { D3DBaseTexture_UnlockTail(this, ArrayIndex); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DTexture */
|
|
|
|
D3DINLINE ULONG WINAPI D3DTexture_AddRef(__in D3DTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DTexture_Release(__in D3DTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DTexture_GetDevice(__in D3DTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DTexture_GetType(__in D3DTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DTexture_IsBusy(__in D3DTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DTexture_IsSet(__in D3DTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DTexture_BlockUntilNotBusy(__in D3DTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE DWORD WINAPI D3DTexture_GetLevelCount(__in D3DTexture *pThis) { return D3DBaseTexture_GetLevelCount((D3DBaseTexture *)pThis); }
|
|
D3DINLINE void WINAPI D3DTexture_GetTailDesc(__in D3DTexture *pThis, __out D3DMIPTAIL_DESC *pDesc) { D3DBaseTexture_GetTailDesc((D3DBaseTexture *)pThis, pDesc); }
|
|
D3DINLINE void WINAPI D3DTexture_LockTail(__in D3DTexture *pThis, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_LockTail((D3DBaseTexture *)pThis, D3DCUBEMAP_FACE_POSITIVE_X, pLockedTail, Flags); }
|
|
D3DINLINE void WINAPI D3DTexture_AsyncLockTail(__in D3DTexture *pThis, D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_AsyncLockTail((D3DBaseTexture *)pThis, AsyncBlock, D3DCUBEMAP_FACE_POSITIVE_X, pLockedTail, Flags); }
|
|
D3DINLINE void WINAPI D3DTexture_UnlockTail(__in D3DTexture *pThis) { D3DBaseTexture_UnlockTail((D3DBaseTexture *)pThis, D3DCUBEMAP_FACE_POSITIVE_X); }
|
|
|
|
void WINAPI D3DTexture_GetLevelDesc(__in D3DTexture *pThis, UINT Level, __out D3DSURFACE_DESC *pDesc);
|
|
__out D3DSurface* WINAPI D3DTexture_GetSurfaceLevel(__in D3DTexture *pThis, UINT Level);
|
|
void WINAPI D3DTexture_LockRect(__in D3DTexture *pThis, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
void WINAPI D3DTexture_AsyncLockRect(__in D3DTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
void WINAPI D3DTexture_UnlockRect(__in D3DTexture *pThis, UINT Level);
|
|
|
|
// Compatibilty wrappers.
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DTexture9_AddRef(__in D3DTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DTexture9_Release(__in D3DTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DTexture9_GetDevice(__in D3DTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DTexture9_GetType(__in D3DTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DTexture9_IsBusy(__in D3DTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DTexture9_IsSet(__in D3DTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DTexture9_BlockUntilNotBusy(__in D3DTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE DWORD WINAPI IDirect3DTexture9_GetLevelCount(__in D3DTexture *pThis) { return D3DBaseTexture_GetLevelCount((D3DBaseTexture *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DTexture9_GetLevelDesc(__in D3DTexture *pThis, UINT Level, __out D3DSURFACE_DESC *pDesc) { D3DTexture_GetLevelDesc(pThis, Level, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DTexture9_GetSurfaceLevel(__in D3DTexture *pThis, UINT Level, __deref_out D3DSurface **ppSurfaceLevel) { return (*ppSurfaceLevel = D3DTexture_GetSurfaceLevel(pThis, Level)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DTexture9_LockRect(__in D3DTexture *pThis, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DTexture_LockRect(pThis, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DTexture9_AsyncLockRect(__in D3DTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DTexture_AsyncLockRect(pThis, AsyncBlock, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DTexture9_UnlockRect(__in D3DTexture *pThis, UINT Level) { D3DTexture_UnlockRect(pThis, Level); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DTexture9_GetTailDesc(__in D3DTexture *pThis, __out D3DMIPTAIL_DESC *pDesc) { D3DTexture_GetTailDesc(pThis, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DTexture9_LockTail(__in D3DTexture *pThis, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DTexture_LockTail(pThis, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DTexture9_AsyncLockTail(__in D3DTexture *pThis, D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DTexture_AsyncLockTail(pThis, AsyncBlock, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DTexture9_UnlockTail(__in D3DTexture *pThis) { D3DTexture_UnlockTail(pThis); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DTexture::GetLevelDesc(UINT Level, __out D3DSURFACE_DESC *pDesc) { D3DTexture_GetLevelDesc(this, Level, pDesc); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DTexture::GetSurfaceLevel(UINT Level, __deref_out D3DSurface **ppSurfaceLevel) { return (*ppSurfaceLevel = D3DTexture_GetSurfaceLevel(this, Level)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DTexture::LockRect(UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DTexture_LockRect(this, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DTexture::AsyncLockRect(D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DTexture_AsyncLockRect(this, AsyncBlock, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DTexture::UnlockRect(UINT Level) { D3DTexture_UnlockRect(this, Level); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DTexture::LockTail(__out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DTexture_LockTail(this, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DTexture::AsyncLockTail(D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DTexture_AsyncLockTail(this, AsyncBlock, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DTexture::UnlockTail() { D3DTexture_UnlockTail(this); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DVolumeTexture */
|
|
|
|
D3DINLINE ULONG WINAPI D3DVolumeTexture_AddRef(__in D3DVolumeTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DVolumeTexture_Release(__in D3DVolumeTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DVolumeTexture_GetDevice(__in D3DVolumeTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DVolumeTexture_GetType(__in D3DVolumeTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DVolumeTexture_IsBusy(__in D3DVolumeTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DVolumeTexture_IsSet(__in D3DVolumeTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DVolumeTexture_BlockUntilNotBusy(__in D3DVolumeTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE DWORD WINAPI D3DVolumeTexture_GetLevelCount(__in D3DVolumeTexture *pThis) { return D3DBaseTexture_GetLevelCount((D3DBaseTexture *)pThis); }
|
|
D3DINLINE void WINAPI D3DVolumeTexture_GetTailDesc(__in D3DVolumeTexture *pThis, __out D3DMIPTAIL_DESC *pDesc) { D3DBaseTexture_GetTailDesc((D3DBaseTexture *)pThis, pDesc); }
|
|
D3DINLINE void WINAPI D3DVolumeTexture_LockTail(__in D3DVolumeTexture *pThis, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_LockTail((D3DBaseTexture *)pThis, D3DCUBEMAP_FACE_POSITIVE_X, pLockedTail, Flags); }
|
|
D3DINLINE void WINAPI D3DVolumeTexture_AsyncLockTail(__in D3DVolumeTexture *pThis, D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_AsyncLockTail((D3DBaseTexture *)pThis, AsyncBlock, D3DCUBEMAP_FACE_POSITIVE_X, pLockedTail, Flags); }
|
|
D3DINLINE void WINAPI D3DVolumeTexture_UnlockTail(__in D3DVolumeTexture *pThis) { D3DBaseTexture_UnlockTail((D3DBaseTexture *)pThis, D3DCUBEMAP_FACE_POSITIVE_X); }
|
|
|
|
void WINAPI D3DVolumeTexture_GetLevelDesc(__in D3DVolumeTexture *pThis, UINT Level, __out D3DVOLUME_DESC *pDesc);
|
|
__out D3DVolume* WINAPI D3DVolumeTexture_GetVolumeLevel(__in D3DVolumeTexture *pThis, UINT Level);
|
|
void WINAPI D3DVolumeTexture_LockBox(__in D3DVolumeTexture *pThis, UINT Level, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags);
|
|
void WINAPI D3DVolumeTexture_AsyncLockBox(__in D3DVolumeTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags);
|
|
void WINAPI D3DVolumeTexture_UnlockBox(__in D3DVolumeTexture *pThis, UINT Level);
|
|
|
|
// Compatibilty wrappers.
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DVolumeTexture9_AddRef(__in D3DVolumeTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DVolumeTexture9_Release(__in D3DVolumeTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolumeTexture9_GetDevice(__in D3DVolumeTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DVolumeTexture9_GetType(__in D3DVolumeTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DVolumeTexture9_IsBusy(__in D3DVolumeTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DVolumeTexture9_IsSet(__in D3DVolumeTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DVolumeTexture9_BlockUntilNotBusy(__in D3DVolumeTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE DWORD WINAPI IDirect3DVolumeTexture9_GetLevelCount(__in D3DVolumeTexture *pThis) { return D3DBaseTexture_GetLevelCount((D3DBaseTexture *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolumeTexture9_GetLevelDesc(__in D3DVolumeTexture *pThis, UINT Level, __out D3DVOLUME_DESC *pDesc) { D3DVolumeTexture_GetLevelDesc(pThis, Level, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DVolumeTexture9_GetVolumeLevel(__in D3DVolumeTexture *pThis, UINT Level, __deref_out D3DVolume **ppVolumeLevel) { return (*ppVolumeLevel = D3DVolumeTexture_GetVolumeLevel(pThis, Level)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolumeTexture9_LockBox(__in D3DVolumeTexture *pThis, UINT Level, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags) { D3DVolumeTexture_LockBox(pThis, Level, pLockedVolume, pBox, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolumeTexture9_AsyncLockBox(__in D3DVolumeTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags) { D3DVolumeTexture_AsyncLockBox(pThis, AsyncBlock, Level, pLockedVolume, pBox, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolumeTexture9_UnlockBox(__in D3DVolumeTexture *pThis, UINT Level) { D3DVolumeTexture_UnlockBox(pThis, Level); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolumeTexture9_GetTailDesc(__in D3DVolumeTexture *pThis, __out D3DMIPTAIL_DESC *pDesc) { D3DVolumeTexture_GetTailDesc(pThis, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolumeTexture9_LockTail(__in D3DVolumeTexture *pThis, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DVolumeTexture_LockTail(pThis, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolumeTexture9_AsyncLockTail(__in D3DVolumeTexture *pThis, D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DVolumeTexture_AsyncLockTail(pThis, AsyncBlock, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolumeTexture9_UnlockTail(__in D3DVolumeTexture *pThis) { D3DVolumeTexture_UnlockTail(pThis); D3DVOIDRETURN; }
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DVolumeTexture::GetLevelDesc(UINT Level, __out D3DVOLUME_DESC *pDesc) { D3DVolumeTexture_GetLevelDesc(this, Level, pDesc); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DVolumeTexture::GetVolumeLevel(UINT Level, __deref_out D3DVolume **ppVolumeLevel) { return (*ppVolumeLevel = D3DVolumeTexture_GetVolumeLevel(this, Level)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVolumeTexture::LockBox(UINT Level, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags) { D3DVolumeTexture_LockBox(this, Level, pLockedVolume, pBox, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVolumeTexture::AsyncLockBox(D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags) { D3DVolumeTexture_AsyncLockBox(this, AsyncBlock, Level, pLockedVolume, pBox, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVolumeTexture::UnlockBox(UINT Level) { D3DVolumeTexture_UnlockBox(this, Level); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVolumeTexture::LockTail(__out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DVolumeTexture_LockTail(this, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVolumeTexture::AsyncLockTail(D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DVolumeTexture_AsyncLockTail(this, AsyncBlock, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVolumeTexture::UnlockTail() { D3DVolumeTexture_UnlockTail(this); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DCubeTexture */
|
|
|
|
D3DINLINE ULONG WINAPI D3DCubeTexture_AddRef(__in D3DCubeTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DCubeTexture_Release(__in D3DCubeTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DCubeTexture_GetDevice(__in D3DCubeTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DCubeTexture_GetType(__in D3DCubeTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DCubeTexture_IsBusy(__in D3DCubeTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DCubeTexture_IsSet(__in D3DCubeTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DCubeTexture_BlockUntilNotBusy(__in D3DCubeTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE DWORD WINAPI D3DCubeTexture_GetLevelCount(__in D3DCubeTexture *pThis) { return D3DBaseTexture_GetLevelCount((D3DBaseTexture *)pThis); }
|
|
D3DINLINE void WINAPI D3DCubeTexture_GetTailDesc(__in D3DCubeTexture *pThis, __out D3DMIPTAIL_DESC *pDesc) { D3DBaseTexture_GetTailDesc((D3DBaseTexture *)pThis, pDesc); }
|
|
D3DINLINE void WINAPI D3DCubeTexture_LockTail(__in D3DCubeTexture *pThis, D3DCUBEMAP_FACES FaceType, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_LockTail((D3DBaseTexture *)pThis, FaceType, pLockedTail, Flags); }
|
|
D3DINLINE void WINAPI D3DCubeTexture_AsyncLockTail(__in D3DCubeTexture *pThis, D3DASYNCBLOCK AsyncBlock, D3DCUBEMAP_FACES FaceType, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_AsyncLockTail((D3DBaseTexture *)pThis, AsyncBlock, FaceType, pLockedTail, Flags); }
|
|
D3DINLINE void WINAPI D3DCubeTexture_UnlockTail(__in D3DCubeTexture *pThis, D3DCUBEMAP_FACES FaceType) { D3DBaseTexture_UnlockTail((D3DBaseTexture *)pThis, FaceType); }
|
|
|
|
void WINAPI D3DCubeTexture_GetLevelDesc(__in D3DCubeTexture *pThis, UINT Level, __out D3DSURFACE_DESC *pDesc);
|
|
__out D3DSurface* WINAPI D3DCubeTexture_GetCubeMapSurface(__in D3DCubeTexture *pThis, D3DCUBEMAP_FACES FaceType, UINT Level);
|
|
void WINAPI D3DCubeTexture_LockRect(__in D3DCubeTexture *pThis, D3DCUBEMAP_FACES FaceType, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
void WINAPI D3DCubeTexture_AsyncLockRect(__in D3DCubeTexture *pThis, D3DASYNCBLOCK AsyncBlock, D3DCUBEMAP_FACES FaceType, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
void WINAPI D3DCubeTexture_UnlockRect(__in D3DCubeTexture *pThis, D3DCUBEMAP_FACES FaceType, UINT Level);
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DCubeTexture9_AddRef(__in D3DCubeTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DCubeTexture9_Release(__in D3DCubeTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCubeTexture9_GetDevice(__in D3DCubeTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DCubeTexture9_GetType(__in D3DCubeTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DCubeTexture9_IsBusy(__in D3DCubeTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DCubeTexture9_IsSet(__in D3DCubeTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DCubeTexture9_BlockUntilNotBusy(__in D3DCubeTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCubeTexture9_GetLevelCount(__in D3DCubeTexture *pThis) { return D3DBaseTexture_GetLevelCount((D3DBaseTexture *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCubeTexture9_GetLevelDesc(__in D3DCubeTexture *pThis, UINT Level, __out D3DSURFACE_DESC *pDesc) { D3DCubeTexture_GetLevelDesc(pThis, Level, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DCubeTexture9_GetCubeMapSurface(__in D3DCubeTexture *pThis, D3DCUBEMAP_FACES FaceType, UINT Level, __deref_out D3DSurface **ppCubeMapSurface) { return (*ppCubeMapSurface = D3DCubeTexture_GetCubeMapSurface(pThis, FaceType, Level)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCubeTexture9_LockRect(__in D3DCubeTexture *pThis, D3DCUBEMAP_FACES FaceType, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DCubeTexture_LockRect(pThis, FaceType, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCubeTexture9_AsyncLockRect(__in D3DCubeTexture *pThis, D3DASYNCBLOCK AsyncBlock, D3DCUBEMAP_FACES FaceType, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DCubeTexture_AsyncLockRect(pThis, AsyncBlock, FaceType, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCubeTexture9_UnlockRect(__in D3DCubeTexture *pThis, D3DCUBEMAP_FACES FaceType, UINT Level) { D3DCubeTexture_UnlockRect(pThis, FaceType, Level); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCubeTexture9_GetTailDesc(__in D3DCubeTexture *pThis, __out D3DMIPTAIL_DESC *pDesc) { D3DCubeTexture_GetTailDesc(pThis, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCubeTexture9_LockTail(__in D3DCubeTexture *pThis, D3DCUBEMAP_FACES FaceType, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DCubeTexture_LockTail(pThis, FaceType, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCubeTexture9_AsyncLockTail(__in D3DCubeTexture *pThis, D3DASYNCBLOCK AsyncBlock, D3DCUBEMAP_FACES FaceType, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DCubeTexture_AsyncLockTail(pThis, AsyncBlock, FaceType, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCubeTexture9_UnlockTail(__in D3DCubeTexture *pThis, D3DCUBEMAP_FACES FaceType) { D3DCubeTexture_UnlockTail(pThis, FaceType); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DCubeTexture::GetLevelDesc(UINT Level, __out D3DSURFACE_DESC *pDesc) { D3DCubeTexture_GetLevelDesc(this, Level, pDesc); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DCubeTexture::GetCubeMapSurface(D3DCUBEMAP_FACES FaceType, UINT Level, __deref_out D3DSurface **ppCubeMapSurface) { return (*ppCubeMapSurface = D3DCubeTexture_GetCubeMapSurface(this, FaceType, Level)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCubeTexture::LockRect(D3DCUBEMAP_FACES FaceType, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DCubeTexture_LockRect(this, FaceType, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCubeTexture::AsyncLockRect(D3DASYNCBLOCK AsyncBlock, D3DCUBEMAP_FACES FaceType, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DCubeTexture_AsyncLockRect(this, AsyncBlock, FaceType, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCubeTexture::UnlockRect(D3DCUBEMAP_FACES FaceType, UINT Level) { D3DCubeTexture_UnlockRect(this, FaceType, Level); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCubeTexture::LockTail(D3DCUBEMAP_FACES FaceType, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DCubeTexture_LockTail(this, FaceType, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCubeTexture::AsyncLockTail(D3DASYNCBLOCK AsyncBlock, D3DCUBEMAP_FACES FaceType, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DCubeTexture_AsyncLockTail(this, AsyncBlock, FaceType, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCubeTexture::UnlockTail(D3DCUBEMAP_FACES FaceType) { D3DCubeTexture_UnlockTail(this, FaceType); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DArrayTexture */
|
|
|
|
D3DINLINE ULONG WINAPI D3DArrayTexture_AddRef(__in D3DArrayTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DArrayTexture_Release(__in D3DArrayTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DArrayTexture_GetDevice(__in D3DArrayTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DArrayTexture_GetType(__in D3DArrayTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DArrayTexture_IsBusy(__in D3DArrayTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DArrayTexture_IsSet(__in D3DArrayTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DArrayTexture_BlockUntilNotBusy(__in D3DArrayTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE DWORD WINAPI D3DArrayTexture_GetLevelCount(__in D3DArrayTexture *pThis) { return D3DBaseTexture_GetLevelCount((D3DBaseTexture *)pThis); }
|
|
D3DINLINE void WINAPI D3DArrayTexture_GetTailDesc(__in D3DArrayTexture *pThis, __out D3DMIPTAIL_DESC *pDesc) { D3DBaseTexture_GetTailDesc((D3DBaseTexture *)pThis, pDesc); }
|
|
D3DINLINE void WINAPI D3DArrayTexture_LockTail(__in D3DArrayTexture *pThis, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_LockTail((D3DBaseTexture *)pThis, ArrayIndex, pLockedTail, Flags); }
|
|
D3DINLINE void WINAPI D3DArrayTexture_AsyncLockTail(__in D3DArrayTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_AsyncLockTail((D3DBaseTexture *)pThis, AsyncBlock, ArrayIndex, pLockedTail, Flags); }
|
|
D3DINLINE void WINAPI D3DArrayTexture_UnlockTail(__in D3DArrayTexture *pThis, UINT ArrayIndex) { D3DBaseTexture_UnlockTail((D3DBaseTexture *)pThis, ArrayIndex); }
|
|
|
|
DWORD WINAPI D3DArrayTexture_GetArraySize(__in D3DArrayTexture *pThis);
|
|
void WINAPI D3DArrayTexture_GetLevelDesc(__in D3DArrayTexture *pThis, UINT Level, __out D3DSURFACE_DESC *pDesc);
|
|
__out D3DSurface* WINAPI D3DArrayTexture_GetArraySurface(__in D3DArrayTexture *pThis, UINT ArrayIndex, UINT Level);
|
|
void WINAPI D3DArrayTexture_LockRect(__in D3DArrayTexture *pThis, UINT ArrayIndex, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
void WINAPI D3DArrayTexture_AsyncLockRect(__in D3DArrayTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
void WINAPI D3DArrayTexture_UnlockRect(__in D3DArrayTexture *pThis, UINT ArrayIndex, UINT Level);
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DArrayTexture9_AddRef(__in D3DArrayTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DArrayTexture9_Release(__in D3DArrayTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DArrayTexture9_GetDevice(__in D3DArrayTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DArrayTexture9_GetType(__in D3DArrayTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DArrayTexture9_IsBusy(__in D3DArrayTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DArrayTexture9_IsSet(__in D3DArrayTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DArrayTexture9_BlockUntilNotBusy(__in D3DArrayTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE DWORD WINAPI IDirect3DArrayTexture9_GetLevelCount(__in D3DArrayTexture *pThis) { return D3DBaseTexture_GetLevelCount((D3DBaseTexture *)pThis); }
|
|
D3DINLINE DWORD WINAPI IDirect3DArrayTexture9_GetArraySize(__in D3DArrayTexture *pThis) { return D3DArrayTexture_GetArraySize(pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DArrayTexture9_GetLevelDesc(__in D3DArrayTexture *pThis, UINT Level, __out D3DSURFACE_DESC *pDesc) { D3DArrayTexture_GetLevelDesc(pThis, Level, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DArrayTexture9_GetArraySurface(__in D3DArrayTexture *pThis, UINT ArrayIndex, UINT Level, __deref_out D3DSurface **ppArraySurface) { return (*ppArraySurface = D3DArrayTexture_GetArraySurface(pThis, ArrayIndex, Level)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DArrayTexture9_LockRect(__in D3DArrayTexture *pThis, UINT ArrayIndex, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DArrayTexture_LockRect(pThis, ArrayIndex, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DArrayTexture9_AsyncLockRect(__in D3DArrayTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DArrayTexture_AsyncLockRect(pThis, AsyncBlock, ArrayIndex, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DArrayTexture9_UnlockRect(__in D3DArrayTexture *pThis, UINT ArrayIndex, UINT Level) { D3DArrayTexture_UnlockRect(pThis, ArrayIndex, Level); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DArrayTexture9_GetTailDesc(__in D3DArrayTexture *pThis, __out D3DMIPTAIL_DESC *pDesc) { D3DArrayTexture_GetTailDesc(pThis, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DArrayTexture9_LockTail(__in D3DArrayTexture *pThis, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DArrayTexture_LockTail(pThis, ArrayIndex, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DArrayTexture9_AsyncLockTail(__in D3DArrayTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DArrayTexture_AsyncLockTail(pThis, AsyncBlock, ArrayIndex, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DArrayTexture9_UnlockTail(__in D3DArrayTexture *pThis, UINT ArrayIndex) { D3DArrayTexture_UnlockTail(pThis, ArrayIndex); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE DWORD WINAPI D3DArrayTexture::GetArraySize() { return D3DArrayTexture_GetArraySize(this); }
|
|
D3DMINLINE D3DVOID WINAPI D3DArrayTexture::GetLevelDesc(UINT Level, __out D3DSURFACE_DESC *pDesc) { D3DArrayTexture_GetLevelDesc(this, Level, pDesc); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DArrayTexture::GetArraySurface(UINT ArrayIndex, UINT Level, __deref_out D3DSurface **ppArraySurface) { return (*ppArraySurface = D3DArrayTexture_GetArraySurface(this, ArrayIndex, Level)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DArrayTexture::LockRect(UINT ArrayIndex, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DArrayTexture_LockRect(this, ArrayIndex, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DArrayTexture::AsyncLockRect(D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DArrayTexture_AsyncLockRect(this, AsyncBlock, ArrayIndex, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DArrayTexture::UnlockRect(UINT ArrayIndex, UINT Level) { D3DArrayTexture_UnlockRect(this, ArrayIndex, Level); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DArrayTexture::LockTail(UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DArrayTexture_LockTail(this, ArrayIndex, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DArrayTexture::AsyncLockTail(D3DASYNCBLOCK AsyncBlock, UINT ArrayIndex, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DArrayTexture_AsyncLockTail(this, AsyncBlock, ArrayIndex, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DArrayTexture::UnlockTail(UINT ArrayIndex) { D3DArrayTexture_UnlockTail(this, ArrayIndex); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DLineTexture */
|
|
|
|
D3DINLINE ULONG WINAPI D3DLineTexture_AddRef(__in D3DLineTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DLineTexture_Release(__in D3DLineTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DLineTexture_GetDevice(__in D3DLineTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DLineTexture_GetType(__in D3DLineTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DLineTexture_IsBusy(__in D3DLineTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DLineTexture_IsSet(__in D3DLineTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DLineTexture_BlockUntilNotBusy(__in D3DLineTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE DWORD WINAPI D3DLineTexture_GetLevelCount(__in D3DLineTexture *pThis) { return D3DBaseTexture_GetLevelCount((D3DBaseTexture *)pThis); }
|
|
D3DINLINE void WINAPI D3DLineTexture_GetTailDesc(__in D3DLineTexture *pThis, __out D3DMIPTAIL_DESC *pDesc) { D3DBaseTexture_GetTailDesc((D3DBaseTexture *)pThis, pDesc); }
|
|
D3DINLINE void WINAPI D3DLineTexture_LockTail(__in D3DLineTexture *pThis, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_LockTail((D3DBaseTexture *)pThis, D3DCUBEMAP_FACE_POSITIVE_X, pLockedTail, Flags); }
|
|
D3DINLINE void WINAPI D3DLineTexture_AsyncLockTail(__in D3DLineTexture *pThis, D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DBaseTexture_AsyncLockTail((D3DBaseTexture *)pThis, AsyncBlock, D3DCUBEMAP_FACE_POSITIVE_X, pLockedTail, Flags); }
|
|
D3DINLINE void WINAPI D3DLineTexture_UnlockTail(__in D3DLineTexture *pThis) { D3DBaseTexture_UnlockTail((D3DBaseTexture *)pThis, D3DCUBEMAP_FACE_POSITIVE_X); }
|
|
|
|
void WINAPI D3DLineTexture_GetLevelDesc(__in D3DLineTexture *pThis, UINT Level, __out D3DSURFACE_DESC *pDesc);
|
|
__out D3DSurface* WINAPI D3DLineTexture_GetSurfaceLevel(__in D3DLineTexture *pThis, UINT Level);
|
|
void WINAPI D3DLineTexture_LockRect(__in D3DLineTexture *pThis, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
void WINAPI D3DLineTexture_AsyncLockRect(__in D3DLineTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
void WINAPI D3DLineTexture_UnlockRect(__in D3DLineTexture *pThis, UINT Level);
|
|
|
|
// Compatibilty wrappers.
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DLineTexture9_AddRef(__in D3DLineTexture *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DLineTexture9_Release(__in D3DLineTexture *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DLineTexture9_GetDevice(__in D3DLineTexture *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DLineTexture9_GetType(__in D3DLineTexture *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DLineTexture9_IsBusy(__in D3DLineTexture *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DLineTexture9_IsSet(__in D3DLineTexture *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DLineTexture9_BlockUntilNotBusy(__in D3DLineTexture *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE DWORD WINAPI IDirect3DLineTexture9_GetLevelCount(__in D3DLineTexture *pThis) { return D3DBaseTexture_GetLevelCount((D3DBaseTexture *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DLineTexture9_GetLevelDesc(__in D3DLineTexture *pThis, UINT Level, __out D3DSURFACE_DESC *pDesc) { D3DLineTexture_GetLevelDesc(pThis, Level, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DLineTexture9_GetSurfaceLevel(__in D3DLineTexture *pThis, UINT Level, __deref_out D3DSurface **ppSurfaceLevel) { return (*ppSurfaceLevel = D3DLineTexture_GetSurfaceLevel(pThis, Level)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DLineTexture9_LockRect(__in D3DLineTexture *pThis, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DLineTexture_LockRect(pThis, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DLineTexture9_AsyncLockRect(__in D3DLineTexture *pThis, D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DLineTexture_AsyncLockRect(pThis, AsyncBlock, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DLineTexture9_UnlockRect(__in D3DLineTexture *pThis, UINT Level) { D3DLineTexture_UnlockRect(pThis, Level); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DLineTexture9_GetTailDesc(__in D3DLineTexture *pThis, __out D3DMIPTAIL_DESC *pDesc) { D3DLineTexture_GetTailDesc(pThis, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DLineTexture9_LockTail(__in D3DLineTexture *pThis, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DLineTexture_LockTail(pThis, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DLineTexture9_AsyncLockTail(__in D3DLineTexture *pThis, D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DLineTexture_AsyncLockTail(pThis, AsyncBlock, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DLineTexture9_UnlockTail(__in D3DLineTexture *pThis) { D3DLineTexture_UnlockTail(pThis); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DLineTexture::GetLevelDesc(UINT Level, __out D3DSURFACE_DESC *pDesc) { D3DLineTexture_GetLevelDesc(this, Level, pDesc); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DLineTexture::GetSurfaceLevel(UINT Level, __deref_out D3DSurface **ppSurfaceLevel) { return (*ppSurfaceLevel = D3DLineTexture_GetSurfaceLevel(this, Level)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DLineTexture::LockRect(UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DLineTexture_LockRect(this, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DLineTexture::AsyncLockRect(D3DASYNCBLOCK AsyncBlock, UINT Level, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DLineTexture_AsyncLockRect(this, AsyncBlock, Level, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DLineTexture::UnlockRect(UINT Level) { D3DLineTexture_UnlockRect(this, Level); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DLineTexture::LockTail(__out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DLineTexture_LockTail(this, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DLineTexture::AsyncLockTail(D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_TAIL *pLockedTail, DWORD Flags) { D3DLineTexture_AsyncLockTail(this, AsyncBlock, pLockedTail, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DLineTexture::UnlockTail() { D3DLineTexture_UnlockTail(this); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DVertexBuffer */
|
|
|
|
D3DINLINE ULONG WINAPI D3DVertexBuffer_AddRef(__in D3DVertexBuffer *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DVertexBuffer_Release(__in D3DVertexBuffer *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DVertexBuffer_GetDevice(__in D3DVertexBuffer *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DVertexBuffer_GetType(__in D3DVertexBuffer *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DVertexBuffer_IsBusy(__in D3DVertexBuffer *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DVertexBuffer_IsSet(__in D3DVertexBuffer *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DVertexBuffer_BlockUntilNotBusy(__in D3DVertexBuffer *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
__out void* WINAPI D3DVertexBuffer_Lock(__in D3DVertexBuffer *pThis, UINT OffsetToLock, UINT SizeToLock, DWORD Flags);
|
|
__out void* WINAPI D3DVertexBuffer_AsyncLock(__in D3DVertexBuffer *pThis, D3DASYNCBLOCK AsyncBlock, UINT OffsetToLock, UINT SizeToLock, DWORD Flags);
|
|
void WINAPI D3DVertexBuffer_GetDesc(__in D3DVertexBuffer *pThis, __out D3DVERTEXBUFFER_DESC *pDesc);
|
|
void WINAPI D3DVertexBuffer_Unlock(__in D3DVertexBuffer *pThis);
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DVertexBuffer9_AddRef(__in D3DVertexBuffer *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DVertexBuffer9_Release(__in D3DVertexBuffer *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVertexBuffer9_GetDevice(__in D3DVertexBuffer *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DVertexBuffer9_GetType(__in D3DVertexBuffer *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DVertexBuffer9_IsBusy(__in D3DVertexBuffer *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DVertexBuffer9_IsSet(__in D3DVertexBuffer *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DVertexBuffer9_BlockUntilNotBusy(__in D3DVertexBuffer *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVertexBuffer9_Lock(__in D3DVertexBuffer *pThis, UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags) { *ppbData = (BYTE*)D3DVertexBuffer_Lock(pThis, OffsetToLock, SizeToLock, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVertexBuffer9_AsyncLock(__in D3DVertexBuffer *pThis, D3DASYNCBLOCK AsyncBlock, UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags) { *ppbData = (BYTE*)D3DVertexBuffer_AsyncLock(pThis, AsyncBlock, OffsetToLock, SizeToLock, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVertexBuffer9_Unlock(__in D3DVertexBuffer *pThis) { D3DVertexBuffer_Unlock(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVertexBuffer9_GetDesc(__in D3DVertexBuffer *pThis, __out D3DVERTEXBUFFER_DESC *pDesc) { D3DVertexBuffer_GetDesc(pThis, pDesc); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DVertexBuffer::Lock(UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags) { *ppbData = (BYTE*)D3DVertexBuffer_Lock(this, OffsetToLock, SizeToLock, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVertexBuffer::AsyncLock(D3DASYNCBLOCK AsyncBlock, UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags) { *ppbData = (BYTE*)D3DVertexBuffer_AsyncLock(this, AsyncBlock, OffsetToLock, SizeToLock, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVertexBuffer::Unlock() { D3DVertexBuffer_Unlock(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVertexBuffer::GetDesc(__out D3DVERTEXBUFFER_DESC *pDesc) { D3DVertexBuffer_GetDesc(this, pDesc); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DIndexBuffer */
|
|
|
|
D3DINLINE ULONG WINAPI D3DIndexBuffer_AddRef(__in D3DIndexBuffer *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DIndexBuffer_Release(__in D3DIndexBuffer *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DIndexBuffer_GetDevice(__in D3DIndexBuffer *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DIndexBuffer_GetType(__in D3DIndexBuffer *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DIndexBuffer_IsBusy(__in D3DIndexBuffer *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DIndexBuffer_IsSet(__in D3DIndexBuffer *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DIndexBuffer_BlockUntilNotBusy(__in D3DIndexBuffer *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
__out void* WINAPI D3DIndexBuffer_Lock(__in D3DIndexBuffer *pThis, UINT OffsetToLock, UINT SizeToLock, DWORD Flags);
|
|
__out void* WINAPI D3DIndexBuffer_AsyncLock(__in D3DIndexBuffer *pThis, D3DASYNCBLOCK AsyncBlock, UINT OffsetToLock, UINT SizeToLock, DWORD Flags);
|
|
void WINAPI D3DIndexBuffer_Unlock(__in D3DIndexBuffer *pThis);
|
|
void WINAPI D3DIndexBuffer_GetDesc(__in D3DIndexBuffer *pThis, __out D3DINDEXBUFFER_DESC *pDesc);
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DIndexBuffer9_AddRef(__in D3DIndexBuffer *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DIndexBuffer9_Release(__in D3DIndexBuffer *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DIndexBuffer9_GetDevice(__in D3DIndexBuffer *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DIndexBuffer9_GetType(__in D3DIndexBuffer *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DIndexBuffer9_IsBusy(__in D3DIndexBuffer *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DIndexBuffer9_IsSet(__in D3DIndexBuffer *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DIndexBuffer9_BlockUntilNotBusy(__in D3DIndexBuffer *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DIndexBuffer9_Lock(__in D3DIndexBuffer *pThis, UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags) { *ppbData = D3DIndexBuffer_Lock(pThis, OffsetToLock, SizeToLock, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DIndexBuffer9_AsyncLock(__in D3DIndexBuffer *pThis, D3DASYNCBLOCK AsyncBlock, UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags) { *ppbData = D3DIndexBuffer_AsyncLock(pThis, AsyncBlock, OffsetToLock, SizeToLock, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DIndexBuffer9_Unlock(__in D3DIndexBuffer *pThis) { D3DIndexBuffer_Unlock(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DIndexBuffer9_GetDesc(__in D3DIndexBuffer *pThis, __out D3DINDEXBUFFER_DESC *pDesc) { D3DIndexBuffer_GetDesc(pThis, pDesc); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DIndexBuffer::Lock(UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags) { *ppbData = D3DIndexBuffer_Lock(this, OffsetToLock, SizeToLock, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DIndexBuffer::AsyncLock(D3DASYNCBLOCK AsyncBlock, UINT OffsetToLock, UINT SizeToLock, __deref_out void **ppbData, DWORD Flags) { *ppbData = D3DIndexBuffer_AsyncLock(this, AsyncBlock, OffsetToLock, SizeToLock, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DIndexBuffer::Unlock() { D3DIndexBuffer_Unlock(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DIndexBuffer::GetDesc(__out D3DINDEXBUFFER_DESC *pDesc) { D3DIndexBuffer_GetDesc(this, pDesc); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DSurface */
|
|
|
|
D3DINLINE ULONG WINAPI D3DSurface_AddRef(__in D3DSurface *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DSurface_Release(__in D3DSurface *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DSurface_GetDevice(__in D3DSurface *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DSurface_GetType(__in D3DSurface *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DSurface_IsBusy(__in D3DSurface *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DSurface_IsSet(__in D3DSurface *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DSurface_BlockUntilNotBusy(__in D3DSurface *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
__out void* WINAPI D3DSurface_GetContainer(__in D3DSurface *pThis, REFIID UnusedRiid);
|
|
void WINAPI D3DSurface_GetDesc(__in D3DSurface *pThis, __out D3DSURFACE_DESC *pDesc);
|
|
void WINAPI D3DSurface_LockRect(__in D3DSurface *pThis, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
void WINAPI D3DSurface_AsyncLockRect(__in D3DSurface *pThis, D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags);
|
|
void WINAPI D3DSurface_UnlockRect(__in D3DSurface *pThis);
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DSurface9_AddRef(__in D3DSurface *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DSurface9_Release(__in D3DSurface *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DSurface9_GetDevice(__in D3DSurface *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DSurface9_GetType(__in D3DSurface *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DSurface9_IsBusy(__in D3DSurface *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DSurface9_IsSet(__in D3DSurface *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DSurface9_BlockUntilNotBusy(__in D3DSurface *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
D3DINLINE HRESULT WINAPI IDirect3DSurface9_GetContainer(__in D3DSurface *pThis, REFIID UnusedRiid, __deref_out void **ppContainer) { return (*ppContainer = D3DSurface_GetContainer(pThis, UnusedRiid)) != NULL ? S_OK : E_FAIL; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DSurface9_GetDesc(__in D3DSurface *pThis, __out D3DSURFACE_DESC *pDesc) { D3DSurface_GetDesc(pThis, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DSurface9_LockRect(__in D3DSurface *pThis, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DSurface_LockRect(pThis, pLockedRect,pRect, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DSurface9_AsyncLockRect(__in D3DSurface *pThis, D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DSurface_AsyncLockRect(pThis, AsyncBlock, pLockedRect,pRect, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DSurface9_UnlockRect(__in D3DSurface *pThis) { D3DSurface_UnlockRect(pThis); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE HRESULT WINAPI D3DSurface::GetContainer(REFIID UnusedRiid, __deref_out void **ppContainer) { return (*ppContainer = D3DSurface_GetContainer(this, UnusedRiid)) != NULL ? S_OK : E_FAIL; }
|
|
D3DMINLINE D3DVOID WINAPI D3DSurface::GetDesc(__out D3DSURFACE_DESC *pDesc) { D3DSurface_GetDesc(this, pDesc); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DSurface::LockRect(__out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DSurface_LockRect(this, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DSurface::AsyncLockRect(D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_RECT *pLockedRect, __in_opt CONST RECT *pRect, DWORD Flags) { D3DSurface_AsyncLockRect(this, AsyncBlock, pLockedRect, pRect, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DSurface::UnlockRect() { D3DSurface_UnlockRect(this); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DVolume */
|
|
|
|
D3DINLINE ULONG WINAPI D3DVolume_AddRef(__in D3DVolume *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DVolume_Release(__in D3DVolume *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DVolume_GetDevice(__in D3DVolume *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DVolume_GetType(__in D3DVolume *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DVolume_IsBusy(__in D3DVolume *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DVolume_IsSet(__in D3DVolume *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DVolume_BlockUntilNotBusy(__in D3DVolume *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
__out void* WINAPI D3DVolume_GetContainer(__in D3DVolume *pThis, REFIID UnusedRiid);
|
|
void WINAPI D3DVolume_GetDesc(__in D3DVolume *pThis, __out D3DVOLUME_DESC *pDesc);
|
|
void WINAPI D3DVolume_LockBox(__in D3DVolume *pThis, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags);
|
|
void WINAPI D3DVolume_AsyncLockBox(__in D3DVolume *pThis, D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags);
|
|
void WINAPI D3DVolume_UnlockBox(__in D3DVolume *pThis);
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DVolume9_AddRef(__in D3DVolume *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DVolume9_Release(__in D3DVolume *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolume9_GetDevice(__in D3DVolume *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DVolume9_GetType(__in D3DVolume *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DVolume9_IsBusy(__in D3DVolume *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DVolume9_IsSet(__in D3DVolume *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DVolume9_BlockUntilNotBusy(__in D3DVolume *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
D3DINLINE HRESULT WINAPI IDirect3DVolume9_GetContainer(__in D3DVolume *pThis, REFIID UnusedRiid, __deref_out void **ppContainer) { return (*ppContainer = D3DVolume_GetContainer(pThis, UnusedRiid)) != NULL ? S_OK : E_FAIL; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolume9_GetDesc(__in D3DVolume *pThis, __out D3DVOLUME_DESC *pDesc) { D3DVolume_GetDesc(pThis, pDesc); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolume9_LockBox(__in D3DVolume *pThis, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags) { D3DVolume_LockBox(pThis, pLockedVolume, pBox, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolume9_AsyncLockBox(__in D3DVolume *pThis, D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags) { D3DVolume_AsyncLockBox(pThis, AsyncBlock, pLockedVolume, pBox, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVolume9_UnlockBox(__in D3DVolume *pThis) { D3DVolume_UnlockBox(pThis); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE HRESULT WINAPI D3DVolume::GetContainer(REFIID UnusedRiid, __deref_out void **ppContainer) { return (*ppContainer = D3DVolume_GetContainer(this, UnusedRiid)) != NULL ? S_OK : E_FAIL; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVolume::GetDesc(__out D3DVOLUME_DESC *pDesc) { D3DVolume_GetDesc(this, pDesc); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVolume::LockBox(__out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags) { D3DVolume_LockBox(this, pLockedVolume, pBox, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVolume::AsyncLockBox(D3DASYNCBLOCK AsyncBlock, __out D3DLOCKED_BOX *pLockedVolume, __in_opt CONST D3DBOX *pBox, DWORD Flags) { D3DVolume_AsyncLockBox(this, AsyncBlock, pLockedVolume, pBox, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVolume::UnlockBox() { D3DVolume_UnlockBox(this); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DVertexDeclaration */
|
|
|
|
D3DINLINE ULONG WINAPI D3DVertexDeclaration_AddRef(__in D3DVertexDeclaration *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DVertexDeclaration_Release(__in D3DVertexDeclaration *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DVertexDeclaration_GetDevice(__in D3DVertexDeclaration *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DVertexDeclaration_GetType(__in D3DVertexDeclaration *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DVertexDeclaration_IsBusy(__in D3DVertexDeclaration *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DVertexDeclaration_IsSet(__in D3DVertexDeclaration *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DVertexDeclaration_BlockUntilNotBusy(__in D3DVertexDeclaration *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
void WINAPI D3DVertexDeclaration_GetDeclaration(__in D3DVertexDeclaration *pThis, __out_ecount_part(*pNumElements, *pNumElements) D3DVERTEXELEMENT9 *pDecl, __inout UINT *pNumElements);
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DVertexDeclaration9_AddRef(__in D3DVertexDeclaration *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DVertexDeclaration9_Release(__in D3DVertexDeclaration *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVertexDeclaration9_GetDevice(__in D3DVertexDeclaration *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DVertexDeclaration9_GetType(__in D3DVertexDeclaration *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DVertexDeclaration9_IsBusy(__in D3DVertexDeclaration *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DVertexDeclaration9_IsSet(__in D3DVertexDeclaration *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DVertexDeclaration9_BlockUntilNotBusy(__in D3DVertexDeclaration *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVertexDeclaration9_GetDeclaration(__in D3DVertexDeclaration *pThis, __out_ecount_part(*pNumElements, *pNumElements) D3DVERTEXELEMENT9 *pDecl, __inout UINT *pNumElements) { D3DVertexDeclaration_GetDeclaration(pThis, pDecl, pNumElements); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DVertexDeclaration::GetDeclaration(__out_ecount_part(*pNumElements, *pNumElements) D3DVERTEXELEMENT9 *pDecl, __inout UINT *pNumElements) { D3DVertexDeclaration_GetDeclaration(this, pDecl, pNumElements); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DVertexShader */
|
|
|
|
D3DINLINE ULONG WINAPI D3DVertexShader_AddRef(__in D3DVertexShader *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DVertexShader_Release(__in D3DVertexShader *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DVertexShader_GetDevice(__in D3DVertexShader *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DVertexShader_GetType(__in D3DVertexShader *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DVertexShader_IsBusy(__in D3DVertexShader *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DVertexShader_IsSet(__in D3DVertexShader *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DVertexShader_BlockUntilNotBusy(__in D3DVertexShader *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
void WINAPI D3DVertexShader_GetFunction(__in D3DVertexShader *pThis, __out_bcount_opt(*pSizeOfData) void *pData, __inout UINT* pSizeOfData);
|
|
void WINAPI D3DVertexShader_Bind(__in D3DVertexShader *pThis, DWORD Flags, __in D3DVertexDeclaration* pVertexDeclaration, __in CONST DWORD* pStreamStrides, __in_opt D3DPixelShader* pPixelShader);
|
|
BOOL WINAPI D3DVertexShader_IsBound(__in D3DVertexShader *pThis);
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DVertexShader9_AddRef(__in D3DVertexShader *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DVertexShader9_Release(__in D3DVertexShader *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVertexShader9_GetDevice(__in D3DVertexShader *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DVertexShader9_GetType(__in D3DVertexShader *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DVertexShader9_IsBusy(__in D3DVertexShader *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DVertexShader9_IsSet(__in D3DVertexShader *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DVertexShader9_BlockUntilNotBusy(__in D3DVertexShader *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVertexShader9_GetFunction(__in D3DVertexShader *pThis, __out_bcount_opt(*pSizeOfData) void *pData, __inout UINT* pSizeOfData) { D3DVertexShader_GetFunction(pThis, pData, pSizeOfData); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DVertexShader9_Bind(__in D3DVertexShader *pThis, DWORD Flags, __in D3DVertexDeclaration* pVertexDeclaration, __in CONST DWORD* pStreamStrides, __in_opt D3DPixelShader* pPixelShader) { D3DVertexShader_Bind(pThis, Flags, pVertexDeclaration, pStreamStrides, pPixelShader); D3DVOIDRETURN; }
|
|
D3DINLINE BOOL WINAPI IDirect3DVertexShader9_IsBound(__in D3DVertexShader *pThis) { return D3DVertexShader_IsBound(pThis); }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DVertexShader::GetFunction(__out_bcount_opt(*pSizeOfData) void *pData, __inout UINT* pSizeOfData) { D3DVertexShader_GetFunction(this, pData, pSizeOfData); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DVertexShader::Bind(DWORD Flags, __in D3DVertexDeclaration* pVertexDeclaration, __in CONST DWORD* pStreamStrides, __in_opt D3DPixelShader* pPixelShader) { D3DVertexShader_Bind(this, Flags, pVertexDeclaration, pStreamStrides, pPixelShader); D3DVOIDRETURN; }
|
|
D3DMINLINE BOOL WINAPI D3DVertexShader::IsBound() { return D3DVertexShader_IsBound(this); }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DPixelShader */
|
|
|
|
D3DINLINE ULONG WINAPI D3DPixelShader_AddRef(__in D3DPixelShader *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DPixelShader_Release(__in D3DPixelShader *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DPixelShader_GetDevice(__in D3DPixelShader *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DPixelShader_GetType(__in D3DPixelShader *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DPixelShader_IsBusy(__in D3DPixelShader *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DPixelShader_IsSet(__in D3DPixelShader *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DPixelShader_BlockUntilNotBusy(__in D3DPixelShader *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
ULONG WINAPI D3DPixelShader_AddRef(__in D3DPixelShader *pThis);
|
|
ULONG WINAPI D3DPixelShader_Release(__in D3DPixelShader *pThis);
|
|
void WINAPI D3DPixelShader_GetDevice(__in D3DPixelShader *pThis, __deref_out D3DDevice **ppDevice);
|
|
void WINAPI D3DPixelShader_GetFunction(__in D3DPixelShader *pThis, __out_bcount_opt(*pSizeOfData) void *pData, __inout UINT* pSizeOfData);
|
|
BOOL WINAPI D3DPixelShader_IsSet(__in D3DPixelShader *pThis, __in D3DDevice *pDevice);
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DPixelShader9_AddRef(__in D3DPixelShader *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DPixelShader9_Release(__in D3DPixelShader *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DPixelShader9_GetDevice(__in D3DPixelShader *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DPixelShader9_GetType(__in D3DPixelShader *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DPixelShader9_IsBusy(__in D3DPixelShader *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DPixelShader9_IsSet(__in D3DPixelShader *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DPixelShader9_BlockUntilNotBusy(__in D3DPixelShader *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
D3DINLINE D3DVOID WINAPI IDirect3DPixelShader9_GetFunction(__in D3DPixelShader *pThis, __out_bcount_opt(*pSizeOfData) void *pData, __inout UINT* pSizeOfData) { D3DPixelShader_GetFunction(pThis, pData, pSizeOfData); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DPixelShader::GetFunction(__out_bcount_opt(*pSizeOfData) void *pData, __inout UINT* pSizeOfData) { D3DPixelShader_GetFunction(this, pData, pSizeOfData); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DConstantBuffer */
|
|
|
|
D3DINLINE ULONG WINAPI D3DConstantBuffer_AddRef(__in D3DConstantBuffer *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DConstantBuffer_Release(__in D3DConstantBuffer *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DConstantBuffer_GetDevice(__in D3DConstantBuffer *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DConstantBuffer_GetType(__in D3DConstantBuffer *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DConstantBuffer_IsBusy(__in D3DConstantBuffer *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DConstantBuffer_IsSet(__in D3DConstantBuffer *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DConstantBuffer_BlockUntilNotBusy(__in D3DConstantBuffer *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
__out D3DVECTOR4* WINAPI D3DConstantBuffer_Lock(__in D3DConstantBuffer *pThis, DWORD Flags);
|
|
__out D3DVECTOR4* WINAPI D3DConstantBuffer_AsyncLock(__in D3DConstantBuffer *pThis, D3DASYNCBLOCK AsyncBlock, DWORD Flags);
|
|
void WINAPI D3DConstantBuffer_Unlock(__in D3DConstantBuffer *pThis);
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DConstantBuffer9_AddRef(__in D3DConstantBuffer *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DConstantBuffer9_Release(__in D3DConstantBuffer *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DConstantBuffer9_GetDevice(__in D3DConstantBuffer *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DConstantBuffer9_GetType(__in D3DConstantBuffer *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DConstantBuffer9_IsBusy(__in D3DConstantBuffer *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DConstantBuffer9_IsSet(__in D3DConstantBuffer *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DConstantBuffer9_BlockUntilNotBusy(__in D3DConstantBuffer *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
D3DINLINE D3DVOID WINAPI IDirect3DConstantBuffer9_Lock(__in D3DConstantBuffer *pThis, __deref_out D3DVECTOR4** ppData, DWORD Flags) { *ppData = D3DConstantBuffer_Lock(pThis, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DConstantBuffer9_AsyncLock(__in D3DConstantBuffer *pThis, D3DASYNCBLOCK AsyncBlock, __deref_out D3DVECTOR4** ppData, DWORD Flags) { *ppData = D3DConstantBuffer_AsyncLock(pThis, AsyncBlock, Flags); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DConstantBuffer9_Unlock(__in D3DConstantBuffer *pThis) { D3DConstantBuffer_Unlock(pThis); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DConstantBuffer::Lock(__deref_out D3DVECTOR4** ppData, DWORD Flags) { *ppData = D3DConstantBuffer_Lock(this, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DConstantBuffer::AsyncLock(D3DASYNCBLOCK AsyncBlock, __deref_out D3DVECTOR4** ppData, DWORD Flags) { *ppData = D3DConstantBuffer_AsyncLock(this, AsyncBlock, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DConstantBuffer::Unlock() { D3DConstantBuffer_Unlock(this); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
/* D3DCommandBuffer */
|
|
|
|
D3DINLINE ULONG WINAPI D3DCommandBuffer_AddRef(__in D3DCommandBuffer *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI D3DCommandBuffer_Release(__in D3DCommandBuffer *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE void WINAPI D3DCommandBuffer_GetDevice(__in D3DCommandBuffer *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI D3DCommandBuffer_GetType(__in D3DCommandBuffer *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DCommandBuffer_IsBusy(__in D3DCommandBuffer *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI D3DCommandBuffer_IsSet(__in D3DCommandBuffer *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI D3DCommandBuffer_BlockUntilNotBusy(__in D3DCommandBuffer *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
void WINAPI D3DCommandBuffer_GetResources(__in D3DCommandBuffer *pThis, DWORD Flags, __out_ecount_opt(*pBufferSize) D3DResource** ppResourceList, __inout DWORD* pBufferSize);
|
|
__out D3DCommandBuffer* WINAPI D3DCommandBuffer_CreateClone(__in D3DCommandBuffer *pThis, DWORD Flags);
|
|
void WINAPI D3DCommandBuffer_GetClone(__in D3DCommandBuffer *pThis, DWORD Flags, __out_bcount_opt(*pHeaderSize) D3DCommandBuffer* pHeaderPart, __inout DWORD* pHeaderSize, __out_bcount_opt(*pPhysicalSize) void* pPhysicalPart, __inout DWORD* pPhysicalSize);
|
|
void WINAPI D3DCommandBuffer_BeginFixupCreation(__in D3DCommandBuffer *pThis);
|
|
HRESULT WINAPI D3DCommandBuffer_EndFixupCreation(__in D3DCommandBuffer *pThis);
|
|
HRESULT WINAPI D3DCommandBuffer_Deconstruct(__in D3DCommandBuffer *pThis, DWORD Flags, __out_bcount_opt(*pHeaderSize) D3DCommandBuffer* pHeaderPart, __inout DWORD* pHeaderSize, __out_bcount_opt(*pPhysicalSize) void* pPhysicalPart, __inout DWORD* pPhysicalSize, __out_bcount_opt(*pInitializationSize) void* pInitializationPart, __inout DWORD* pInitializationSize);
|
|
void WINAPI D3DCommandBuffer_BeginReconstruction(__in D3DCommandBuffer *pThis, DWORD Flags, __in void* pPhysicalPart, __in void* pInitializationPart);
|
|
void WINAPI D3DCommandBuffer_EndReconstruction(__in D3DCommandBuffer *pThis);
|
|
void WINAPI D3DCommandBuffer_BeginDynamicFixups(__in D3DCommandBuffer *pThis);
|
|
void WINAPI D3DCommandBuffer_EndDynamicFixups(__in D3DCommandBuffer *pThis);
|
|
DWORD WINAPI D3DCommandBuffer_CreateSurfacesFixup(__in D3DCommandBuffer *pThis, DWORD Flags, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI D3DCommandBuffer_CreateClipRectFixup(__in D3DCommandBuffer *pThis, DWORD Flags, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI D3DCommandBuffer_CreateViewportFixup(__in D3DCommandBuffer *pThis, DWORD Flags, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI D3DCommandBuffer_CreateVertexShaderConstantFFixup(__in D3DCommandBuffer *pThis, DWORD Flags, DWORD StartRegister, DWORD Vector4fCount, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI D3DCommandBuffer_CreatePixelShaderConstantFFixup(__in D3DCommandBuffer *pThis, DWORD Flags, DWORD StartRegister, DWORD Vector4fCount, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI D3DCommandBuffer_CreateVertexShaderFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DVertexShader* pVertexShader, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI D3DCommandBuffer_CreatePixelShaderFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DPixelShader* pPixelShader, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI D3DCommandBuffer_CreateTextureFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DBaseTexture* pTexture, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI D3DCommandBuffer_CreateIndexBufferFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DIndexBuffer* pIndexBuffer, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI D3DCommandBuffer_CreateVertexBufferFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DVertexBuffer* pVertexBuffer, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI D3DCommandBuffer_CreateConstantBufferFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DConstantBuffer* pConstantBuffer, DWORD StartMarker, DWORD StopMarker);
|
|
DWORD WINAPI D3DCommandBuffer_CreateCommandBufferFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DCommandBuffer* pCommandBuffer, DWORD StartMarker, DWORD StopMarker);
|
|
void WINAPI D3DCommandBuffer_SetSurfaces(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in CONST D3DSURFACES* pSurfaces);
|
|
void WINAPI D3DCommandBuffer_SetClipRect(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in CONST RECT* pRect);
|
|
void WINAPI D3DCommandBuffer_SetViewport(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in CONST D3DVIEWPORT9* pViewport);
|
|
void WINAPI D3DCommandBuffer_SetVertexShaderConstantF(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in CONST float* pConstantData);
|
|
void WINAPI D3DCommandBuffer_SetPixelShaderConstantF(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in CONST float* pConstantData);
|
|
void WINAPI D3DCommandBuffer_SetVertexShader(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DVertexShader* pVertexShader);
|
|
void WINAPI D3DCommandBuffer_SetPixelShader(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DPixelShader* pPixelShader);
|
|
void WINAPI D3DCommandBuffer_SetTexture(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DBaseTexture* pTexture);
|
|
void WINAPI D3DCommandBuffer_SetIndexBuffer(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DIndexBuffer* pIndexBuffer);
|
|
void WINAPI D3DCommandBuffer_SetVertexBuffer(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DVertexBuffer* pVertexBuffer);
|
|
void WINAPI D3DCommandBuffer_SetConstantBuffer(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DConstantBuffer* pConstantBuffer);
|
|
void WINAPI D3DCommandBuffer_SetCommandBuffer(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DCommandBuffer* pCommandBuffer);
|
|
|
|
D3DINLINE ULONG WINAPI IDirect3DCommandBuffer9_AddRef(__in D3DCommandBuffer *pThis) { return D3DResource_AddRef((D3DResource *)pThis); }
|
|
D3DINLINE ULONG WINAPI IDirect3DCommandBuffer9_Release(__in D3DCommandBuffer *pThis) { return D3DResource_Release((D3DResource *)pThis); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_GetDevice(__in D3DCommandBuffer *pThis, __deref_out D3DDevice **ppDevice) { D3DResource_GetDevice((D3DResource *)pThis, ppDevice); D3DVOIDRETURN; }
|
|
D3DINLINE D3DRESOURCETYPE WINAPI IDirect3DCommandBuffer9_GetType(__in D3DCommandBuffer *pThis) { return D3DResource_GetType((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DCommandBuffer9_IsBusy(__in D3DCommandBuffer *pThis) { return D3DResource_IsBusy((D3DResource *)pThis); }
|
|
D3DINLINE BOOL WINAPI IDirect3DCommandBuffer9_IsSet(__in D3DCommandBuffer *pThis, __in D3DDevice *pDevice) { return D3DResource_IsSet((D3DResource *)pThis, pDevice); }
|
|
D3DINLINE void WINAPI IDirect3DCommandBuffer9_BlockUntilNotBusy(__in D3DCommandBuffer *pThis) { D3DResource_BlockUntilNotBusy((D3DResource *)pThis); }
|
|
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_GetResources(__in D3DCommandBuffer *pThis, DWORD Flags, __out_ecount_opt(*pBufferSize) D3DResource** ppResourceList, __inout DWORD* pBufferSize) { D3DCommandBuffer_GetResources(pThis, Flags, ppResourceList, pBufferSize); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DCommandBuffer9_CreateClone(__in D3DCommandBuffer *pThis, DWORD Flags, __deref_out D3DCommandBuffer** ppCommandBuffer) { return (*ppCommandBuffer = D3DCommandBuffer_CreateClone(pThis, Flags)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_GetClone(__in D3DCommandBuffer *pThis, DWORD Flags, __out_bcount_opt(*pHeaderSize) D3DCommandBuffer* pHeaderPart, __inout DWORD* pHeaderSize, __out_bcount_opt(*pPhysicalSize) void* pPhysicalPart, __inout DWORD* pPhysicalSize) { D3DCommandBuffer_GetClone(pThis, Flags, pHeaderPart, pHeaderSize, pPhysicalPart, pPhysicalSize); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_BeginFixupCreation(__in D3DCommandBuffer *pThis) { D3DCommandBuffer_BeginFixupCreation(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE HRESULT WINAPI IDirect3DCommandBuffer9_EndFixupCreation(__in D3DCommandBuffer *pThis) { return D3DCommandBuffer_EndFixupCreation(pThis); }
|
|
D3DINLINE HRESULT WINAPI IDirect3DCommandBuffer9_Deconstruct(__in D3DCommandBuffer *pThis, DWORD Flags, __out_bcount_opt(*pHeaderSize) D3DCommandBuffer* pHeaderPart, __inout DWORD* pHeaderSize, __out_bcount_opt(*pPhysicalSize) void* pPhysicalPart, __inout DWORD* pPhysicalSize, __out_bcount_opt(*pInitializationSize) void* pInitializationPart, __inout DWORD* pInitializationSize) { return D3DCommandBuffer_Deconstruct(pThis, Flags, pHeaderPart, pHeaderSize, pPhysicalPart, pPhysicalSize, pInitializationPart, pInitializationSize); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_BeginReconstruction(__in D3DCommandBuffer *pThis, DWORD Flags, __in void* pPhysicalPart, __in void* pInitializationPart) { D3DCommandBuffer_BeginReconstruction(pThis, Flags, pPhysicalPart, pInitializationPart); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_EndReconstruction(__in D3DCommandBuffer *pThis) { D3DCommandBuffer_EndReconstruction(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_BeginDynamicFixups(__in D3DCommandBuffer *pThis) { D3DCommandBuffer_BeginDynamicFixups(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_EndDynamicFixups(__in D3DCommandBuffer *pThis) { D3DCommandBuffer_EndDynamicFixups(pThis); D3DVOIDRETURN; }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreateSurfacesFixup(__in D3DCommandBuffer *pThis, DWORD Flags, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateSurfacesFixup(pThis, Flags, StartMarker, StopMarker); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreateClipRectFixup(__in D3DCommandBuffer *pThis, DWORD Flags, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateClipRectFixup(pThis, Flags, StartMarker, StopMarker); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreateViewportFixup(__in D3DCommandBuffer *pThis, DWORD Flags, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateViewportFixup(pThis, Flags, StartMarker, StopMarker); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreateVertexShaderConstantFFixup(__in D3DCommandBuffer *pThis, DWORD Flags, DWORD StartRegister, DWORD Vector4fCount, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateVertexShaderConstantFFixup(pThis, Flags, StartRegister, Vector4fCount, StartMarker, StopMarker); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreatePixelShaderConstantFFixup(__in D3DCommandBuffer *pThis, DWORD Flags, DWORD StartRegister, DWORD Vector4fCount, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreatePixelShaderConstantFFixup(pThis, Flags, StartRegister, Vector4fCount, StartMarker, StopMarker); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreateVertexShaderFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DVertexShader* pVertexShader, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateVertexShaderFixup(pThis, Flags, pVertexShader, StartMarker, StopMarker); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreatePixelShaderFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DPixelShader* pPixelShader, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreatePixelShaderFixup(pThis, Flags, pPixelShader, StartMarker, StopMarker); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreateTextureFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DBaseTexture* pTexture, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateTextureFixup(pThis, Flags, pTexture, StartMarker, StopMarker); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreateIndexBufferFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DIndexBuffer* pIndexBuffer, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateIndexBufferFixup(pThis, Flags, pIndexBuffer, StartMarker, StopMarker); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreateVertexBufferFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DVertexBuffer* pVertexBuffer, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateVertexBufferFixup(pThis, Flags, pVertexBuffer, StartMarker, StopMarker); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreateConstantBufferFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DConstantBuffer* pConstantBuffer, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateConstantBufferFixup(pThis, Flags, pConstantBuffer, StartMarker, StopMarker); }
|
|
D3DINLINE DWORD WINAPI IDirect3DCommandBuffer9_CreateCommandBufferFixup(__in D3DCommandBuffer *pThis, DWORD Flags, __in D3DCommandBuffer* pCommandBuffer, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateCommandBufferFixup(pThis, Flags, pCommandBuffer, StartMarker, StopMarker); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetSurfaces(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in CONST D3DSURFACES* pSurfaces) { D3DCommandBuffer_SetSurfaces(pThis, FixupHandle, pSurfaces); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetClipRect(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in CONST RECT* pRect) { D3DCommandBuffer_SetClipRect(pThis, FixupHandle, pRect); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetViewport(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in CONST D3DVIEWPORT9* pViewport) { D3DCommandBuffer_SetViewport(pThis, FixupHandle, pViewport); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetVertexShaderConstantF(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in CONST float* pConstantData) { D3DCommandBuffer_SetVertexShaderConstantF(pThis, FixupHandle, pConstantData); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetPixelShaderConstantF(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in CONST float* pConstantData) { D3DCommandBuffer_SetPixelShaderConstantF(pThis, FixupHandle, pConstantData); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetVertexShader(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DVertexShader* pVertexShader) { D3DCommandBuffer_SetVertexShader(pThis, FixupHandle, pVertexShader); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetPixelShader(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DPixelShader* pPixelShader) { D3DCommandBuffer_SetPixelShader(pThis, FixupHandle, pPixelShader); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetTexture(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DBaseTexture* pTexture) { D3DCommandBuffer_SetTexture(pThis, FixupHandle, pTexture); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetIndexBuffer(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DIndexBuffer* pIndexBuffer) { D3DCommandBuffer_SetIndexBuffer(pThis, FixupHandle, pIndexBuffer); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetVertexBuffer(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DVertexBuffer* pVertexBuffer) { D3DCommandBuffer_SetVertexBuffer(pThis, FixupHandle, pVertexBuffer); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetConstantBuffer(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DConstantBuffer* pConstantBuffer) { D3DCommandBuffer_SetConstantBuffer(pThis, FixupHandle, pConstantBuffer); D3DVOIDRETURN; }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DCommandBuffer9_SetCommandBuffer(__in D3DCommandBuffer *pThis, DWORD FixupHandle, __in D3DCommandBuffer* pCommandBuffer) { D3DCommandBuffer_SetCommandBuffer(pThis, FixupHandle, pCommandBuffer); D3DVOIDRETURN; }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::GetResources(DWORD Flags, __out_ecount_opt(*pBufferSize) D3DResource** ppResourceList, __inout DWORD* pBufferSize) { D3DCommandBuffer_GetResources(this, Flags, ppResourceList, pBufferSize); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DCommandBuffer::CreateClone(DWORD Flags, __deref_out D3DCommandBuffer** ppCommandBuffer) { return (*ppCommandBuffer = D3DCommandBuffer_CreateClone(this, Flags)) != NULL ? S_OK : E_OUTOFMEMORY; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::GetClone(DWORD Flags, __out_bcount_opt(*pHeaderSize) D3DCommandBuffer* pHeaderPart, __inout DWORD* pHeaderSize, __out_bcount_opt(*pPhysicalSize) void* pPhysicalPart, __inout DWORD* pPhysicalSize) { D3DCommandBuffer_GetClone(this, Flags, pHeaderPart, pHeaderSize, pPhysicalPart, pPhysicalSize); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::BeginFixupCreation() { D3DCommandBuffer_BeginFixupCreation(this); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DCommandBuffer::EndFixupCreation() { return D3DCommandBuffer_EndFixupCreation(this); }
|
|
D3DMINLINE HRESULT WINAPI D3DCommandBuffer::Deconstruct(DWORD Flags, __out_bcount_opt(*pHeaderSize) D3DCommandBuffer* pHeaderPart, __inout DWORD* pHeaderSize, __out_bcount_opt(*pPhysicalSize) void* pPhysicalPart, __inout DWORD* pPhysicalSize, __out_bcount_opt(*pInitializationSize) void* pInitializationPart, __inout DWORD* pInitializationSize) { return D3DCommandBuffer_Deconstruct(this, Flags, pHeaderPart, pHeaderSize, pPhysicalPart, pPhysicalSize, pInitializationPart, pInitializationSize); }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::BeginReconstruction(DWORD Flags, __in void* pPhysicalPart, __in void* pInitializationPart) { D3DCommandBuffer_BeginReconstruction(this, Flags, pPhysicalPart, pInitializationPart); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::EndReconstruction() { D3DCommandBuffer_EndReconstruction(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::BeginDynamicFixups() { D3DCommandBuffer_BeginDynamicFixups(this); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::EndDynamicFixups() { D3DCommandBuffer_EndDynamicFixups(this); D3DVOIDRETURN; }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreateSurfacesFixup(DWORD Flags, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateSurfacesFixup(this, Flags, StartMarker, StopMarker); }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreateClipRectFixup(DWORD Flags, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateClipRectFixup(this, Flags, StartMarker, StopMarker); }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreateViewportFixup(DWORD Flags, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateViewportFixup(this, Flags, StartMarker, StopMarker); }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreateVertexShaderConstantFFixup(DWORD Flags, DWORD StartRegister, DWORD Vector4fCount, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateVertexShaderConstantFFixup(this, Flags, StartRegister, Vector4fCount, StartMarker, StopMarker); }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreatePixelShaderConstantFFixup(DWORD Flags, DWORD StartRegister, DWORD Vector4fCount, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreatePixelShaderConstantFFixup(this, Flags, StartRegister, Vector4fCount, StartMarker, StopMarker); }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreateVertexShaderFixup(DWORD Flags, __in D3DVertexShader* pVertexShader, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateVertexShaderFixup(this, Flags, pVertexShader, StartMarker, StopMarker); }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreatePixelShaderFixup(DWORD Flags, __in D3DPixelShader* pPixelShader, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreatePixelShaderFixup(this, Flags, pPixelShader, StartMarker, StopMarker); }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreateTextureFixup(DWORD Flags, __in D3DBaseTexture* pTexture, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateTextureFixup(this, Flags, pTexture, StartMarker, StopMarker); }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreateIndexBufferFixup(DWORD Flags, __in D3DIndexBuffer* pIndexBuffer, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateIndexBufferFixup(this, Flags, pIndexBuffer, StartMarker, StopMarker); }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreateVertexBufferFixup(DWORD Flags, __in D3DVertexBuffer* pVertexBuffer, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateVertexBufferFixup(this, Flags, pVertexBuffer, StartMarker, StopMarker); }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreateConstantBufferFixup(DWORD Flags, __in D3DConstantBuffer* pConstantBuffer, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateConstantBufferFixup(this, Flags, pConstantBuffer, StartMarker, StopMarker); }
|
|
D3DMINLINE DWORD WINAPI D3DCommandBuffer::CreateCommandBufferFixup(DWORD Flags, __in D3DCommandBuffer* pCommandBuffer, DWORD StartMarker, DWORD StopMarker) { return D3DCommandBuffer_CreateCommandBufferFixup(this, Flags, pCommandBuffer, StartMarker, StopMarker); }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetSurfaces(DWORD FixupHandle, __in CONST D3DSURFACES* pSurfaces) { D3DCommandBuffer_SetSurfaces(this, FixupHandle, pSurfaces); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetClipRect(DWORD FixupHandle, __in CONST RECT* pRect) { D3DCommandBuffer_SetClipRect(this, FixupHandle, pRect); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetViewport(DWORD FixupHandle, __in CONST D3DVIEWPORT9* pViewport) { D3DCommandBuffer_SetViewport(this, FixupHandle, pViewport); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetVertexShaderConstantF(DWORD FixupHandle, __in CONST float* pConstantData) { D3DCommandBuffer_SetVertexShaderConstantF(this, FixupHandle, pConstantData); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetPixelShaderConstantF(DWORD FixupHandle, __in CONST float* pConstantData) { D3DCommandBuffer_SetPixelShaderConstantF(this, FixupHandle, pConstantData); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetVertexShader(DWORD FixupHandle, __in D3DVertexShader* pVertexShader) { D3DCommandBuffer_SetVertexShader(this, FixupHandle, pVertexShader); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetPixelShader(DWORD FixupHandle, __in D3DPixelShader* pPixelShader) { D3DCommandBuffer_SetPixelShader(this, FixupHandle, pPixelShader); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetTexture(DWORD FixupHandle, __in D3DBaseTexture* pTexture) { D3DCommandBuffer_SetTexture(this, FixupHandle, pTexture); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetIndexBuffer(DWORD FixupHandle, __in D3DIndexBuffer* pIndexBuffer) { D3DCommandBuffer_SetIndexBuffer(this, FixupHandle, pIndexBuffer); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetVertexBuffer(DWORD FixupHandle, __in D3DVertexBuffer* pVertexBuffer) { D3DCommandBuffer_SetVertexBuffer(this, FixupHandle, pVertexBuffer); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetConstantBuffer(DWORD FixupHandle, __in D3DConstantBuffer* pConstantBuffer) { D3DCommandBuffer_SetConstantBuffer(this, FixupHandle, pConstantBuffer); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DCommandBuffer::SetCommandBuffer(DWORD FixupHandle, __in D3DCommandBuffer* pCommandBuffer) { D3DCommandBuffer_SetCommandBuffer(this, FixupHandle, pCommandBuffer); D3DVOIDRETURN; }
|
|
|
|
#endif __cplusplus
|
|
|
|
void WINAPI D3DAsyncCommandBufferCall_FixupAndSignalEx(__in D3DAsyncCommandBufferCall* pAsyncCommandBufferCall, __in_ecount_opt(CommandBufferCount) D3DCommandBuffer** ppUserCommandBuffers, __in_ecount_opt(CommandBufferCount) DWORD* pPredicationSelects, DWORD CommandBufferCount, DWORD Flags);
|
|
D3DINLINE void WINAPI D3DAsyncCommandBufferCall_FixupAndSignal(__in D3DAsyncCommandBufferCall* pAsyncCommandBufferCall, D3DCommandBuffer* pUserCommandBuffer, DWORD PredicationSelect, DWORD Flags) { D3DAsyncCommandBufferCall_FixupAndSignalEx(pAsyncCommandBufferCall, &pUserCommandBuffer, &PredicationSelect, 1, Flags); }
|
|
HRESULT WINAPI D3DAsyncCommandBufferCall_Reset(__in D3DAsyncCommandBufferCall* pD3DCall, __in_opt D3DTAGCOLLECTION* pInheritTags, __in_opt D3DTAGCOLLECTION* pPersistTags, DWORD NumSegments, DWORD Flags);
|
|
|
|
D3DINLINE D3DVOID WINAPI IDirect3DAsyncCommandBufferCall9_FixupAndSignal(__in D3DAsyncCommandBufferCall* pAsyncCommandBufferCall, __in_opt D3DCommandBuffer* pUserCommandBuffer, DWORD PredicationSelect, DWORD Flags) { D3DAsyncCommandBufferCall_FixupAndSignalEx(pAsyncCommandBufferCall, &pUserCommandBuffer, &PredicationSelect, 1, Flags); }
|
|
D3DINLINE D3DVOID WINAPI IDirect3DAsyncCommandBufferCall9_FixupAndSignalEx(__in D3DAsyncCommandBufferCall* pAsyncCommandBufferCall, __in_ecount_opt(CommandBufferCount) D3DCommandBuffer** pUserCommandBuffers, __in_ecount_opt(CommandBufferCount) DWORD* PredicationSelects, DWORD CommandBufferCount, DWORD Flags) { D3DAsyncCommandBufferCall_FixupAndSignalEx(pAsyncCommandBufferCall, pUserCommandBuffers, PredicationSelects, CommandBufferCount, Flags); }
|
|
D3DINLINE HRESULT WINAPI IDirect3DAsyncCommandBufferCall9_Reset(__in D3DAsyncCommandBufferCall* pD3DCall, __in_opt D3DTAGCOLLECTION* pInheritTags, __in_opt D3DTAGCOLLECTION* pPersistTags, DWORD NumSegments, DWORD Flags) { return D3DAsyncCommandBufferCall_Reset(pD3DCall, pInheritTags, pPersistTags, NumSegments, Flags); }
|
|
|
|
#ifdef __cplusplus
|
|
|
|
D3DMINLINE D3DVOID WINAPI D3DAsyncCommandBufferCall::FixupAndSignal(__in_opt D3DCommandBuffer* pUserCommandBuffer, DWORD PredicationSelect, DWORD Flags) { D3DAsyncCommandBufferCall_FixupAndSignalEx(this, &pUserCommandBuffer, &PredicationSelect, 1, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE D3DVOID WINAPI D3DAsyncCommandBufferCall::FixupAndSignalEx(__in_ecount_opt(CommandBufferCount) D3DCommandBuffer** ppUserCommandBuffers, __in_ecount_opt(CommandBufferCount) DWORD* pPredicationSelects, DWORD CommandBufferCount, DWORD Flags) { D3DAsyncCommandBufferCall_FixupAndSignalEx(this, ppUserCommandBuffers, pPredicationSelects, CommandBufferCount, Flags); D3DVOIDRETURN; }
|
|
D3DMINLINE HRESULT WINAPI D3DAsyncCommandBufferCall::Reset(__in_opt D3DTAGCOLLECTION* pInheritTags, __in_opt D3DTAGCOLLECTION* pPersistTags, DWORD NumSegments, DWORD Flags) { return D3DAsyncCommandBufferCall_Reset(this, pInheritTags, pPersistTags, NumSegments, Flags); }
|
|
|
|
#endif __cplusplus
|
|
|
|
#ifdef __cplusplus
|
|
};
|
|
#endif
|
|
|
|
/* PIX Utility Functions */
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
HRESULT WINAPI PIXCaptureTimingFrame(__in_z char *pFilename);
|
|
HRESULT WINAPI PIXCaptureGpuFrame(__in_z char *pFilename);
|
|
|
|
#if defined(USE_D3D_PIX_METHODS) && defined(_XBOX)
|
|
|
|
HRESULT WINAPI PIXEnableTextureTracking(DWORD TrackerThread, DWORD TrackerCommandBufferSize, __in_opt D3DTEXTURETRACKERERRORCALLBACK pCallback);
|
|
HRESULT WINAPI PIXDisableTextureTracking();
|
|
HRESULT WINAPI PIXBeginTextureCapture(DWORD AutoSaveFrequency, DWORD ScreenCaptureFrequency, DWORD ChannelSoftCompareThreshold, __in_z const char* pFilename);
|
|
HRESULT WINAPI PIXEndTextureCapture();
|
|
|
|
HRESULT WINAPI PIXIgnoreTexture(__in D3DBaseTexture* pTexture);
|
|
HRESULT WINAPI PIXStopIgnoringTexture(__in D3DBaseTexture* pTexture);
|
|
HRESULT WINAPI PIXIgnoreMemoryRange(__in_bcount(Size) const void* pBaseAddress, DWORD Size);
|
|
HRESULT WINAPI PIXStopIgnoringMemoryRange(__in_bcount(Size) const void* pBaseAddress, DWORD Size);
|
|
HRESULT WINAPI PIXSetTextureName(__in D3DBaseTexture* pTexture, __in_z const char* pName);
|
|
HRESULT WINAPI PIXReportNewTexture(__in D3DBaseTexture* pTexture);
|
|
HRESULT WINAPI PIXReportDeletedTexture(__in D3DBaseTexture* pTexture, BOOL BaseDeleted, BOOL MipDeleted);
|
|
HRESULT WINAPI PIXReportMovedMemoryRange(__in_bcount(Size) const void* pDestinationAddress, __in_bcount(Size) const void* pSourceAddress, DWORD Size);
|
|
HRESULT WINAPI PIXReportFreedMemoryRange(__in_bcount(Size) const void* pAddress, DWORD Size);
|
|
|
|
#else
|
|
|
|
// Make PIX texture tracking methods disappear on retail and X86 builds
|
|
|
|
D3DINLINE HRESULT WINAPI PIXEnableTextureTracking(DWORD TrackerThread, DWORD TrackerCommandBufferSize, __in_opt D3DTEXTURETRACKERERRORCALLBACK pCallback) { return S_OK; }
|
|
D3DINLINE HRESULT WINAPI PIXDisableTextureTracking() { return S_OK; }
|
|
D3DINLINE HRESULT WINAPI PIXBeginTextureCapture(DWORD AutoSaveFrequency, DWORD ScreenCaptureFrequency, DWORD ChannelSoftCompareThreshold, __in_z const char* pFilename) { return S_OK; }
|
|
D3DINLINE HRESULT WINAPI PIXEndTextureCapture() { return S_OK; }
|
|
|
|
D3DINLINE HRESULT WINAPI PIXIgnoreTexture(__in D3DBaseTexture* pTexture) { return S_OK; }
|
|
D3DINLINE HRESULT WINAPI PIXStopIgnoringTexture(__in D3DBaseTexture* pTexture) { return S_OK; }
|
|
D3DINLINE HRESULT WINAPI PIXIgnoreMemoryRange(__in_bcount(Size) const void* pBaseAddress, DWORD Size) { return S_OK; }
|
|
D3DINLINE HRESULT WINAPI PIXStopIgnoringMemoryRange(__in_bcount(Size) const void* pBaseAddress, DWORD Size) { return S_OK; }
|
|
D3DINLINE HRESULT WINAPI PIXSetTextureName(__in D3DBaseTexture* pTexture, __in_z const char* pName) { return S_OK; }
|
|
D3DINLINE HRESULT WINAPI PIXReportNewTexture(__in D3DBaseTexture* pTexture) { return S_OK; }
|
|
D3DINLINE HRESULT WINAPI PIXReportDeletedTexture(__in D3DBaseTexture* pTexture, BOOL BaseDeleted, BOOL MipDeleted) { return S_OK; }
|
|
D3DINLINE HRESULT WINAPI PIXReportMovedMemoryRange(__in_bcount(Size) const void* pDestinationAddress, __in_bcount(Size) const void* pSourceAddress, DWORD Size) { return S_OK; }
|
|
D3DINLINE HRESULT WINAPI PIXReportFreedMemoryRange(__in_bcount(Size) const void* pAddress, DWORD Size) { return S_OK; }
|
|
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
};
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Additional C++ definitions for Win64 compatibility
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef __cplusplus
|
|
|
|
template < typename T >
|
|
D3DINLINE
|
|
T* D3DNew()
|
|
{
|
|
void* const ptr = D3DAlloc(sizeof(T));
|
|
return new(ptr) T;
|
|
}
|
|
|
|
template < typename T >
|
|
D3DINLINE
|
|
void D3DDelete(T* ptr)
|
|
{
|
|
ptr->~T();
|
|
D3DFree(ptr);
|
|
}
|
|
|
|
template < typename T >
|
|
D3DINLINE
|
|
T* D3DNewArray(SIZE_T n)
|
|
{
|
|
void* const mem = ::D3DAlloc(sizeof(SIZE_T) + sizeof(void*) + 16 + sizeof(T) * n);
|
|
UINT_PTR const ptrAligned = (UINT_PTR(mem) + sizeof(SIZE_T) + sizeof(void*) + 15) & ~15;
|
|
|
|
*(SIZE_T*)(ptrAligned - sizeof(SIZE_T)) = n;
|
|
*(void**)(ptrAligned - sizeof(SIZE_T) - sizeof(void*)) = mem;
|
|
|
|
T* const ptr = (T*)ptrAligned;
|
|
|
|
for (SIZE_T i = 0; i < n; ++i)
|
|
{
|
|
new(ptr + i) T;
|
|
}
|
|
|
|
return ptr;
|
|
}
|
|
|
|
template < typename T >
|
|
D3DINLINE
|
|
void D3DDeleteArray(T* ptr)
|
|
{
|
|
UINT_PTR const ptrAligned = UINT_PTR(ptr);
|
|
|
|
SIZE_T const n = *(SIZE_T*)(ptrAligned - sizeof(SIZE_T));
|
|
void* const mem = *(void**)(ptrAligned - sizeof(SIZE_T) - sizeof(void*));
|
|
|
|
for (SIZE_T i = 0; i < n; ++i)
|
|
{
|
|
ptr[i].~T();
|
|
}
|
|
|
|
::D3DFree(mem);
|
|
}
|
|
|
|
template < typename T >
|
|
__forceinline
|
|
T* D3DDWORDToPtr(DWORD dw)
|
|
{
|
|
return (T*) ::D3DDWORDToPtr(dw);
|
|
}
|
|
|
|
#endif
|
|
|
|
#pragma warning( pop )
|
|
|
|
#endif /* _D3D9_H_ */
|