d3dcompiler.h File Reference

#include "d3d11shader.h"
#include "d3d12shader.h"

Include dependency graph for d3dcompiler.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	D3DCOMPILER_DLL_A   "d3dcompiler_47.dll"
#define	D3DCOMPILER_DLL   WINELIB_NAME_AW(D3DCOMPILER_DLL_)
#define	D3DCOMPILE_DEBUG   0x00000001
#define	D3DCOMPILE_SKIP_VALIDATION   0x00000002
#define	D3DCOMPILE_SKIP_OPTIMIZATION   0x00000004
#define	D3DCOMPILE_PACK_MATRIX_ROW_MAJOR   0x00000008
#define	D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR   0x00000010
#define	D3DCOMPILE_PARTIAL_PRECISION   0x00000020
#define	D3DCOMPILE_FORCE_VS_SOFTWARE_NO_OPT   0x00000040
#define	D3DCOMPILE_FORCE_PS_SOFTWARE_NO_OPT   0x00000080
#define	D3DCOMPILE_NO_PRESHADER   0x00000100
#define	D3DCOMPILE_AVOID_FLOW_CONTROL   0x00000200
#define	D3DCOMPILE_PREFER_FLOW_CONTROL   0x00000400
#define	D3DCOMPILE_ENABLE_STRICTNESS   0x00000800
#define	D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY   0x00001000
#define	D3DCOMPILE_IEEE_STRICTNESS   0x00002000
#define	D3DCOMPILE_OPTIMIZATION_LEVEL0   0x00004000
#define	D3DCOMPILE_OPTIMIZATION_LEVEL1   0x00000000
#define	D3DCOMPILE_OPTIMIZATION_LEVEL2   0x0000c000
#define	D3DCOMPILE_OPTIMIZATION_LEVEL3   0x00008000
#define	D3DCOMPILE_RESERVED16   0x00010000
#define	D3DCOMPILE_RESERVED17   0x00020000
#define	D3DCOMPILE_WARNINGS_ARE_ERRORS   0x00040000
#define	D3DCOMPILE_RESOURCES_MAY_ALIAS   0x00080000
#define	D3DCOMPILE_ENABLE_UNBOUNDED_DESCRIPTOR_TABLES   0x00100000
#define	D3DCOMPILE_ALL_RESOURCES_BOUND   0x00200000
#define	D3DCOMPILE_DEBUG_NAME_FOR_SOURCE   0x00400000
#define	D3DCOMPILE_DEBUG_NAME_FOR_BINARY   0x00800000
#define	D3DCOMPILE_EFFECT_CHILD_EFFECT   0x00000001
#define	D3DCOMPILE_EFFECT_ALLOW_SLOW_OPS   0x00000002
#define	D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_LATEST   0x00000000
#define	D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_0   0x00000010
#define	D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_1   0x00000020
#define	D3D_DISASM_ENABLE_COLOR_CODE   0x00000001
#define	D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS   0x00000002
#define	D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING   0x00000004
#define	D3D_DISASM_ENABLE_INSTRUCTION_CYCLE   0x00000008
#define	D3D_DISASM_DISABLE_DEBUG_INFO   0x00000010
#define	D3D_DISASM_ENABLE_INSTRUCTION_OFFSET   0x00000020
#define	D3D_DISASM_INSTRUCTION_ONLY   0x00000040
#define	D3D_DISASM_PRINT_HEX_LITERALS   0x00000080
#define	D3D_COMPILE_STANDARD_FILE_INCLUDE   ((ID3DInclude *)(UINT_PTR)1)

Typedefs
typedef HRESULT(WINAPI *	pD3DCompile) (const void *data, SIZE_T data_size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages)
typedef enum D3DCOMPILER_STRIP_FLAGS	D3DCOMPILER_STRIP_FLAGS
typedef enum D3D_BLOB_PART	D3D_BLOB_PART
typedef HRESULT(WINAPI *	pD3DDisassemble) (const void *data, SIZE_T data_size, UINT flags, const char *comments, ID3DBlob **disassembly)
typedef HRESULT(WINAPI *	pD3DPreprocess) (const void *data, SIZE_T size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, ID3DBlob **shader, ID3DBlob **error_messages)

Enumerations
enum	D3DCOMPILER_STRIP_FLAGS {   D3DCOMPILER_STRIP_REFLECTION_DATA = 0x1 , D3DCOMPILER_STRIP_DEBUG_INFO = 0x2 , D3DCOMPILER_STRIP_TEST_BLOBS = 0x4 , D3DCOMPILER_STRIP_PRIVATE_DATA = 0x8 ,   D3DCOMPILER_STRIP_ROOT_SIGNATURE = 0x10 , D3DCOMPILER_STRIP_FORCE_DWORD = 0x7fffffff }
enum	D3D_BLOB_PART {   D3D_BLOB_INPUT_SIGNATURE_BLOB , D3D_BLOB_OUTPUT_SIGNATURE_BLOB , D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB , D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB ,   D3D_BLOB_ALL_SIGNATURE_BLOB , D3D_BLOB_DEBUG_INFO , D3D_BLOB_LEGACY_SHADER , D3D_BLOB_XNA_PREPASS_SHADER ,   D3D_BLOB_XNA_SHADER , D3D_BLOB_PDB , D3D_BLOB_PRIVATE_DATA , D3D_BLOB_ROOT_SIGNATURE ,   D3D_BLOB_DEBUG_NAME , D3D_BLOB_TEST_ALTERNATE_SHADER = 0x8000 , D3D_BLOB_TEST_COMPILE_DETAILS , D3D_BLOB_TEST_COMPILE_PERF ,   D3D_BLOB_TEST_COMPILE_REPORT }

Functions
HRESULT WINAPI	D3DCompile (const void *data, SIZE_T data_size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages)
HRESULT WINAPI	D3DCompile2 (const void *data, SIZE_T data_size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, const char *target, UINT sflags, UINT eflags, UINT secondary_flags, const void *secondary_data, SIZE_T secondary_data_size, ID3DBlob **shader, ID3DBlob **error_messages)
HRESULT WINAPI	D3DStripShader (const void *data, SIZE_T data_size, UINT flags, ID3DBlob **blob)
HRESULT WINAPI	D3DDisassemble (const void *data, SIZE_T data_size, UINT flags, const char *comments, ID3DBlob **disassembly)
HRESULT WINAPI	D3DCompileFromFile (const WCHAR *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *includes, const char *entrypoint, const char *target, UINT flags1, UINT flags2, ID3DBlob **code, ID3DBlob **errors)
HRESULT WINAPI	D3DGetBlobPart (const void *data, SIZE_T data_size, D3D_BLOB_PART part, UINT flags, ID3DBlob **blob)
HRESULT WINAPI	D3DGetInputSignatureBlob (const void *data, SIZE_T data_size, ID3DBlob **blob)
HRESULT WINAPI	D3DGetOutputSignatureBlob (const void *data, SIZE_T data_size, ID3DBlob **blob)
HRESULT WINAPI	D3DGetInputAndOutputSignatureBlob (const void *data, SIZE_T data_size, ID3DBlob **blob)
HRESULT WINAPI	D3DGetDebugInfo (const void *data, SIZE_T data_size, ID3DBlob **blob)
HRESULT WINAPI	D3DReadFileToBlob (const WCHAR *filename, ID3DBlob **contents)
HRESULT WINAPI	D3DWriteBlobToFile (ID3DBlob *blob, const WCHAR *filename, BOOL overwrite)
HRESULT WINAPI	D3DReflect (const void *data, SIZE_T data_size, REFIID riid, void **reflector)
HRESULT WINAPI	D3DCreateBlob (SIZE_T data_size, ID3DBlob **blob)
HRESULT WINAPI	D3DPreprocess (const void *data, SIZE_T size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, ID3DBlob **shader, ID3DBlob **error_messages)
HRESULT WINAPI	D3DCreateLinker (ID3D11Linker **linker)
HRESULT WINAPI	D3DLoadModule (const void *data, SIZE_T size, ID3D11Module **module)

Variables
static const WCHAR	D3DCOMPILER_DLL_W [] = {'d','3','d','c','o','m','p','i','l','e','r','_','4','7','.','d','l','l',0}

Macro Definition Documentation

D3D_COMPILE_STANDARD_FILE_INCLUDE

#define D3D_COMPILE_STANDARD_FILE_INCLUDE   ((ID3DInclude *)(UINT_PTR)1)

Definition at line 85 of file d3dcompiler.h.

D3D_DISASM_DISABLE_DEBUG_INFO

#define D3D_DISASM_DISABLE_DEBUG_INFO   0x00000010

Definition at line 80 of file d3dcompiler.h.

D3D_DISASM_ENABLE_COLOR_CODE

#define D3D_DISASM_ENABLE_COLOR_CODE   0x00000001

Definition at line 76 of file d3dcompiler.h.

D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS

#define D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS   0x00000002

Definition at line 77 of file d3dcompiler.h.

D3D_DISASM_ENABLE_INSTRUCTION_CYCLE

#define D3D_DISASM_ENABLE_INSTRUCTION_CYCLE   0x00000008

Definition at line 79 of file d3dcompiler.h.

D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING

#define D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING   0x00000004

Definition at line 78 of file d3dcompiler.h.

D3D_DISASM_ENABLE_INSTRUCTION_OFFSET

#define D3D_DISASM_ENABLE_INSTRUCTION_OFFSET   0x00000020

Definition at line 81 of file d3dcompiler.h.

D3D_DISASM_INSTRUCTION_ONLY

#define D3D_DISASM_INSTRUCTION_ONLY   0x00000040

Definition at line 82 of file d3dcompiler.h.

D3D_DISASM_PRINT_HEX_LITERALS

#define D3D_DISASM_PRINT_HEX_LITERALS   0x00000080

Definition at line 83 of file d3dcompiler.h.

D3DCOMPILE_ALL_RESOURCES_BOUND

#define D3DCOMPILE_ALL_RESOURCES_BOUND   0x00200000

Definition at line 65 of file d3dcompiler.h.

D3DCOMPILE_AVOID_FLOW_CONTROL

#define D3DCOMPILE_AVOID_FLOW_CONTROL   0x00000200

Definition at line 51 of file d3dcompiler.h.

D3DCOMPILE_DEBUG

#define D3DCOMPILE_DEBUG   0x00000001

Definition at line 42 of file d3dcompiler.h.

D3DCOMPILE_DEBUG_NAME_FOR_BINARY

#define D3DCOMPILE_DEBUG_NAME_FOR_BINARY   0x00800000

Definition at line 67 of file d3dcompiler.h.

D3DCOMPILE_DEBUG_NAME_FOR_SOURCE

#define D3DCOMPILE_DEBUG_NAME_FOR_SOURCE   0x00400000

Definition at line 66 of file d3dcompiler.h.

D3DCOMPILE_EFFECT_ALLOW_SLOW_OPS

#define D3DCOMPILE_EFFECT_ALLOW_SLOW_OPS   0x00000002

Definition at line 70 of file d3dcompiler.h.

D3DCOMPILE_EFFECT_CHILD_EFFECT

#define D3DCOMPILE_EFFECT_CHILD_EFFECT   0x00000001

Definition at line 69 of file d3dcompiler.h.

D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY

#define D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY   0x00001000

Definition at line 54 of file d3dcompiler.h.

D3DCOMPILE_ENABLE_STRICTNESS

#define D3DCOMPILE_ENABLE_STRICTNESS   0x00000800

Definition at line 53 of file d3dcompiler.h.

D3DCOMPILE_ENABLE_UNBOUNDED_DESCRIPTOR_TABLES

#define D3DCOMPILE_ENABLE_UNBOUNDED_DESCRIPTOR_TABLES   0x00100000

Definition at line 64 of file d3dcompiler.h.

D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_0

#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_0   0x00000010

Definition at line 73 of file d3dcompiler.h.

D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_1

#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_1   0x00000020

Definition at line 74 of file d3dcompiler.h.

D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_LATEST

#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_LATEST   0x00000000

Definition at line 72 of file d3dcompiler.h.

D3DCOMPILE_FORCE_PS_SOFTWARE_NO_OPT

#define D3DCOMPILE_FORCE_PS_SOFTWARE_NO_OPT   0x00000080

Definition at line 49 of file d3dcompiler.h.

D3DCOMPILE_FORCE_VS_SOFTWARE_NO_OPT

#define D3DCOMPILE_FORCE_VS_SOFTWARE_NO_OPT   0x00000040

Definition at line 48 of file d3dcompiler.h.

D3DCOMPILE_IEEE_STRICTNESS

#define D3DCOMPILE_IEEE_STRICTNESS   0x00002000

Definition at line 55 of file d3dcompiler.h.

D3DCOMPILE_NO_PRESHADER

#define D3DCOMPILE_NO_PRESHADER   0x00000100

Definition at line 50 of file d3dcompiler.h.

D3DCOMPILE_OPTIMIZATION_LEVEL0

#define D3DCOMPILE_OPTIMIZATION_LEVEL0   0x00004000

Definition at line 56 of file d3dcompiler.h.

D3DCOMPILE_OPTIMIZATION_LEVEL1

#define D3DCOMPILE_OPTIMIZATION_LEVEL1   0x00000000

Definition at line 57 of file d3dcompiler.h.

D3DCOMPILE_OPTIMIZATION_LEVEL2

#define D3DCOMPILE_OPTIMIZATION_LEVEL2   0x0000c000

Definition at line 58 of file d3dcompiler.h.

D3DCOMPILE_OPTIMIZATION_LEVEL3

#define D3DCOMPILE_OPTIMIZATION_LEVEL3   0x00008000

Definition at line 59 of file d3dcompiler.h.

D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR

#define D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR   0x00000010

Definition at line 46 of file d3dcompiler.h.

D3DCOMPILE_PACK_MATRIX_ROW_MAJOR

#define D3DCOMPILE_PACK_MATRIX_ROW_MAJOR   0x00000008

Definition at line 45 of file d3dcompiler.h.

D3DCOMPILE_PARTIAL_PRECISION

#define D3DCOMPILE_PARTIAL_PRECISION   0x00000020

Definition at line 47 of file d3dcompiler.h.

D3DCOMPILE_PREFER_FLOW_CONTROL

#define D3DCOMPILE_PREFER_FLOW_CONTROL   0x00000400

Definition at line 52 of file d3dcompiler.h.

D3DCOMPILE_RESERVED16

#define D3DCOMPILE_RESERVED16   0x00010000

Definition at line 60 of file d3dcompiler.h.

D3DCOMPILE_RESERVED17

#define D3DCOMPILE_RESERVED17   0x00020000

Definition at line 61 of file d3dcompiler.h.

D3DCOMPILE_RESOURCES_MAY_ALIAS

#define D3DCOMPILE_RESOURCES_MAY_ALIAS   0x00080000

Definition at line 63 of file d3dcompiler.h.

D3DCOMPILE_SKIP_OPTIMIZATION

#define D3DCOMPILE_SKIP_OPTIMIZATION   0x00000004

Definition at line 44 of file d3dcompiler.h.

D3DCOMPILE_SKIP_VALIDATION

#define D3DCOMPILE_SKIP_VALIDATION   0x00000002

Definition at line 43 of file d3dcompiler.h.

D3DCOMPILE_WARNINGS_ARE_ERRORS

#define D3DCOMPILE_WARNINGS_ARE_ERRORS   0x00040000

Definition at line 62 of file d3dcompiler.h.

D3DCOMPILER_DLL

#define D3DCOMPILER_DLL   WINELIB_NAME_AW(D3DCOMPILER_DLL_)

Definition at line 36 of file d3dcompiler.h.

D3DCOMPILER_DLL_A

#define D3DCOMPILER_DLL_A   "d3dcompiler_47.dll"

Definition at line 35 of file d3dcompiler.h.

Typedef Documentation

D3D_BLOB_PART

typedef enum D3D_BLOB_PART D3D_BLOB_PART

D3DCOMPILER_STRIP_FLAGS

typedef enum D3DCOMPILER_STRIP_FLAGS D3DCOMPILER_STRIP_FLAGS

pD3DCompile

typedef HRESULT(WINAPI * pD3DCompile) (const void *data, SIZE_T data_size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages)

Definition at line 90 of file d3dcompiler.h.

pD3DDisassemble

typedef HRESULT(WINAPI * pD3DDisassemble) (const void *data, SIZE_T data_size, UINT flags, const char *comments, ID3DBlob **disassembly)

Definition at line 134 of file d3dcompiler.h.

pD3DPreprocess

typedef HRESULT(WINAPI * pD3DPreprocess) (const void *data, SIZE_T size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, ID3DBlob **shader, ID3DBlob **error_messages)

Definition at line 152 of file d3dcompiler.h.

Enumeration Type Documentation

D3D_BLOB_PART

enum D3D_BLOB_PART

Enumerator
D3D_BLOB_INPUT_SIGNATURE_BLOB
D3D_BLOB_OUTPUT_SIGNATURE_BLOB
D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB
D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB
D3D_BLOB_ALL_SIGNATURE_BLOB
D3D_BLOB_DEBUG_INFO
D3D_BLOB_LEGACY_SHADER
D3D_BLOB_XNA_PREPASS_SHADER
D3D_BLOB_XNA_SHADER
D3D_BLOB_PDB
D3D_BLOB_PRIVATE_DATA
D3D_BLOB_ROOT_SIGNATURE
D3D_BLOB_DEBUG_NAME
D3D_BLOB_TEST_ALTERNATE_SHADER
D3D_BLOB_TEST_COMPILE_DETAILS
D3D_BLOB_TEST_COMPILE_PERF
D3D_BLOB_TEST_COMPILE_REPORT

Definition at line 111 of file d3dcompiler.h.

{
    D3D_BLOB_INPUT_SIGNATURE_BLOB,
    D3D_BLOB_OUTPUT_SIGNATURE_BLOB,
    D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB,
    D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB,
    D3D_BLOB_ALL_SIGNATURE_BLOB,
    D3D_BLOB_DEBUG_INFO,
    D3D_BLOB_LEGACY_SHADER,
    D3D_BLOB_XNA_PREPASS_SHADER,
    D3D_BLOB_XNA_SHADER,
    D3D_BLOB_PDB,
    D3D_BLOB_PRIVATE_DATA,
    D3D_BLOB_ROOT_SIGNATURE,
    D3D_BLOB_DEBUG_NAME,
    D3D_BLOB_TEST_ALTERNATE_SHADER = 0x8000,
    D3D_BLOB_TEST_COMPILE_DETAILS,
    D3D_BLOB_TEST_COMPILE_PERF,
    D3D_BLOB_TEST_COMPILE_REPORT
} D3D_BLOB_PART;

D3DCOMPILER_STRIP_FLAGS

enum D3DCOMPILER_STRIP_FLAGS

Enumerator
D3DCOMPILER_STRIP_REFLECTION_DATA
D3DCOMPILER_STRIP_DEBUG_INFO
D3DCOMPILER_STRIP_TEST_BLOBS
D3DCOMPILER_STRIP_PRIVATE_DATA
D3DCOMPILER_STRIP_ROOT_SIGNATURE
D3DCOMPILER_STRIP_FORCE_DWORD

Definition at line 99 of file d3dcompiler.h.

{
    D3DCOMPILER_STRIP_REFLECTION_DATA = 0x1,
    D3DCOMPILER_STRIP_DEBUG_INFO = 0x2,
    D3DCOMPILER_STRIP_TEST_BLOBS = 0x4,
    D3DCOMPILER_STRIP_PRIVATE_DATA = 0x8,
    D3DCOMPILER_STRIP_ROOT_SIGNATURE = 0x10,
    D3DCOMPILER_STRIP_FORCE_DWORD = 0x7fffffff
} D3DCOMPILER_STRIP_FLAGS;

Function Documentation

D3DCompile()

HRESULT WINAPI D3DCompile	(	const void *	data,
		SIZE_T	data_size,
		const char *	filename,
		const D3D_SHADER_MACRO *	defines,
		ID3DInclude *	include,
		const char *	entrypoint,
		const char *	target,
		UINT	sflags,
		UINT	eflags,
		ID3DBlob **	shader,
		ID3DBlob **	error_messages
	)

Definition at line 639 of file compiler.c.

{
    TRACE("data %p, data_size %Iu, filename %s, defines %p, include %p, entrypoint %s, "
            "target %s, sflags %#x, eflags %#x, shader %p, error_messages %p.\n",
            data, data_size, debugstr_a(filename), defines, include, debugstr_a(entrypoint),
            debugstr_a(target), sflags, eflags, shader, error_messages);
 
    return D3DCompile2(data, data_size, filename, defines, include, entrypoint, target, sflags,
            eflags, 0, NULL, 0, shader, error_messages);
}

Referenced by call_D3DCompile(), compile_shader_(), create_effect(), d2d_device_context_init(), D3DCompileFromFile(), D3DX10CompileFromMemory(), D3DX11CompileFromMemory(), d3dx9_effect_init(), D3DXCompileShader(), D3DXCompileShaderFromFileW(), test_fail(), test_hlsl_double(), test_include(), and test_no_output_blob().

D3DCompile2()

HRESULT WINAPI D3DCompile2	(	const void *	data,
		SIZE_T	data_size,
		const char *	filename,
		const D3D_SHADER_MACRO *	defines,
		ID3DInclude *	include,
		const char *	entrypoint,
		const char *	target,
		UINT	sflags,
		UINT	eflags,
		UINT	secondary_flags,
		const void *	secondary_data,
		SIZE_T	secondary_data_size,
		ID3DBlob **	shader,
		ID3DBlob **	error_messages
	)

Definition at line 451 of file compiler.c.

{
    struct d3dcompiler_include_from_file include_from_file;
    struct vkd3d_shader_preprocess_info preprocess_info;
    struct vkd3d_shader_hlsl_source_info hlsl_info;
    struct vkd3d_shader_compile_option options[6];
    struct vkd3d_shader_compile_info compile_info;
    struct vkd3d_shader_compile_option *option;
    struct vkd3d_shader_code byte_code;
    const D3D_SHADER_MACRO *macro;
    char *messages;
    HRESULT hr;
    int ret;
 
    TRACE("data %p, data_size %Iu, filename %s, macros %p, include %p, entry_point %s, "
            "profile %s, flags %#x, effect_flags %#x, secondary_flags %#x, secondary_data %p, "
            "secondary_data_size %Iu, shader_blob %p, messages_blob %p.\n",
            data, data_size, debugstr_a(filename), macros, include, debugstr_a(entry_point),
            debugstr_a(profile), flags, effect_flags, secondary_flags, secondary_data,
            secondary_data_size, shader_blob, messages_blob);
 
    if (include == D3D_COMPILE_STANDARD_FILE_INCLUDE)
    {
        include_from_file.ID3DInclude_iface.lpVtbl = &d3dcompiler_include_from_file_vtbl;
        include_from_file.initial_filename = filename ? filename : "";
        include = &include_from_file.ID3DInclude_iface;
    }
 
    if (flags & ~(D3DCOMPILE_DEBUG | D3DCOMPILE_PACK_MATRIX_ROW_MAJOR | D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR
            | D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY))
    {
        FIXME("Ignoring flags %#x.\n", flags);
    }
    if (effect_flags & ~D3DCOMPILE_EFFECT_CHILD_EFFECT)
        FIXME("Ignoring effect flags %#x.\n", effect_flags & ~D3DCOMPILE_EFFECT_CHILD_EFFECT);
    if (secondary_flags)
        FIXME("Ignoring secondary flags %#x.\n", secondary_flags);
 
    if (shader_blob)
        *shader_blob = NULL;
    if (messages_blob)
        *messages_blob = NULL;
 
    option = &options[0];
    option->name = VKD3D_SHADER_COMPILE_OPTION_API_VERSION;
    option->value = VKD3D_SHADER_API_VERSION_1_3;
 
    compile_info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO;
    compile_info.next = &preprocess_info;
    compile_info.source.code = data;
    compile_info.source.size = data_size;
    compile_info.source_type = VKD3D_SHADER_SOURCE_HLSL;
    compile_info.target_type = get_target_for_profile(profile);
    compile_info.options = options;
    compile_info.option_count = 1;
    compile_info.log_level = VKD3D_SHADER_LOG_INFO;
    compile_info.source_name = filename;
 
    preprocess_info.type = VKD3D_SHADER_STRUCTURE_TYPE_PREPROCESS_INFO;
    preprocess_info.next = &hlsl_info;
    preprocess_info.macros = (const struct vkd3d_shader_macro *)macros;
    preprocess_info.macro_count = 0;
    if (macros)
    {
        for (macro = macros; macro->Name; ++macro)
            ++preprocess_info.macro_count;
    }
    preprocess_info.pfn_open_include = open_include;
    preprocess_info.pfn_close_include = close_include;
    preprocess_info.include_context = include;
 
    hlsl_info.type = VKD3D_SHADER_STRUCTURE_TYPE_HLSL_SOURCE_INFO;
    hlsl_info.next = NULL;
    hlsl_info.profile = profile;
    hlsl_info.entry_point = entry_point;
    hlsl_info.secondary_code.code = secondary_data;
    hlsl_info.secondary_code.size = secondary_data_size;
 
    if (!(flags & D3DCOMPILE_DEBUG))
    {
        option = &options[compile_info.option_count++];
        option->name = VKD3D_SHADER_COMPILE_OPTION_STRIP_DEBUG;
        option->value = true;
    }
 
    if (flags & D3DCOMPILE_PACK_MATRIX_ROW_MAJOR)
    {
        option = &options[compile_info.option_count++];
        option->name = VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ORDER;
        option->value = VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ROW_MAJOR;
    }
    else if (flags & D3DCOMPILE_PACK_MATRIX_COLUMN_MAJOR)
    {
        option = &options[compile_info.option_count++];
        option->name = VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ORDER;
        option->value = VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_COLUMN_MAJOR;
    }
 
    if (flags & D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY)
    {
        option = &options[compile_info.option_count++];
        option->name = VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY;
        option->value = VKD3D_SHADER_COMPILE_OPTION_BACKCOMPAT_MAP_SEMANTIC_NAMES;
    }
 
    if (effect_flags & D3DCOMPILE_EFFECT_CHILD_EFFECT)
    {
        option = &options[compile_info.option_count++];
        option->name = VKD3D_SHADER_COMPILE_OPTION_CHILD_EFFECT;
        option->value = true;
    }
 
#if D3D_COMPILER_VERSION <= 39
    option = &options[compile_info.option_count++];
    option->name = VKD3D_SHADER_COMPILE_OPTION_INCLUDE_EMPTY_BUFFERS_IN_EFFECTS;
    option->value = true;
#endif
 
    ret = vkd3d_shader_compile(&compile_info, &byte_code, &messages);
 
    if (ret)
        ERR("Failed to compile shader, vkd3d result %d.\n", ret);
 
    if (messages)
    {
        if (*messages && ERR_ON(d3dcompiler))
        {
            const char *ptr = messages;
            const char *line;
 
            ERR("Shader log:\n");
            while ((line = get_line(&ptr)))
            {
                ERR("    %.*s", (int)(ptr - line), line);
            }
            ERR("\n");
        }
 
        if (messages_blob)
        {
            size_t size = strlen(messages);
            if (FAILED(hr = D3DCreateBlob(size, messages_blob)))
            {
                vkd3d_shader_free_messages(messages);
                vkd3d_shader_free_shader_code(&byte_code);
                return hr;
            }
            memcpy(ID3D10Blob_GetBufferPointer(*messages_blob), messages, size);
        }
 
        vkd3d_shader_free_messages(messages);
    }
 
    if (ret)
        return hresult_from_vkd3d_result(ret);
 
    if (!shader_blob)
    {
        vkd3d_shader_free_shader_code(&byte_code);
        return S_OK;
    }
 
    /* Unlike other effect profiles fx_4_x is using DXBC container. */
    if (!strcmp(profile, "fx_4_0") || !strcmp(profile, "fx_4_1"))
    {
        struct vkd3d_shader_dxbc_section_desc section = { .tag = TAG_FX10, .data = byte_code };
        struct vkd3d_shader_code dxbc;
 
        ret = vkd3d_shader_serialize_dxbc(1, &section, &dxbc, NULL);
        vkd3d_shader_free_shader_code(&byte_code);
        if (ret)
            return hresult_from_vkd3d_result(ret);
 
        byte_code = dxbc;
    }
 
    if (SUCCEEDED(hr = D3DCreateBlob(byte_code.size, shader_blob)))
        memcpy(ID3D10Blob_GetBufferPointer(*shader_blob), byte_code.code, byte_code.size);
 
    vkd3d_shader_free_shader_code(&byte_code);
 
    return hr;
}

Referenced by D3DCompile().

D3DCompileFromFile()

HRESULT WINAPI D3DCompileFromFile	(	const WCHAR *	filename,
		const D3D_SHADER_MACRO *	defines,
		ID3DInclude *	includes,
		const char *	entrypoint,
		const char *	target,
		UINT	flags1,
		UINT	flags2,
		ID3DBlob **	code,
		ID3DBlob **	errors
	)

Definition at line 743 of file compiler.c.

{
    char filename_a[MAX_PATH], *source = NULL;
    DWORD source_size, read_size;
    HANDLE file;
    HRESULT hr;
 
    TRACE("filename %s, defines %p, include %p, entrypoint %s, target %s, flags1 %#x, flags2 %#x, "
            "code %p, errors %p.\n", debugstr_w(filename), defines, include, debugstr_a(entrypoint),
            debugstr_a(target), flags1, flags2, code, errors);
 
    file = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (file == INVALID_HANDLE_VALUE)
        return HRESULT_FROM_WIN32(GetLastError());
 
    source_size = GetFileSize(file, NULL);
    if (source_size == INVALID_FILE_SIZE)
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        goto end;
    }
 
    if (!(source = malloc(source_size)))
    {
        hr = E_OUTOFMEMORY;
        goto end;
    }
 
    if (!ReadFile(file, source, source_size, &read_size, NULL) || read_size != source_size)
    {
        WARN("Failed to read file contents.\n");
        hr = E_FAIL;
        goto end;
    }
 
    WideCharToMultiByte(CP_ACP, 0, filename, -1, filename_a, sizeof(filename_a), NULL, NULL);
 
    hr = D3DCompile(source, source_size, filename_a, defines, include, entrypoint, target,
            flags1, flags2, code, errors);
 
end:
    free(source);
    CloseHandle(file);
    return hr;
}

Referenced by D3DX11CompileFromFileW(), and test_include().

D3DCreateBlob()

HRESULT WINAPI D3DCreateBlob	(	SIZE_T	data_size,
		ID3DBlob **	blob
	)

Definition at line 133 of file blob.c.

{
    struct d3dcompiler_blob *object;
    HRESULT hr;
 
    TRACE("data_size %Iu, blob %p.\n", data_size, blob);
 
    if (!blob)
    {
        WARN("Invalid blob specified.\n");
        return D3DERR_INVALIDCALL;
    }
 
    object = calloc(1, sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    hr = d3dcompiler_blob_init(object, data_size);
    if (FAILED(hr))
    {
        WARN("Failed to initialize blob, hr %#lx.\n", hr);
        free(object);
        return hr;
    }
 
    *blob = &object->ID3DBlob_iface;
 
    TRACE("Created ID3DBlob %p\n", *blob);
 
    return S_OK;
}

Referenced by assemble_shader(), D3DCompile2(), d3dcompiler_get_blob_part(), d3dcompiler_strip_shader(), D3DDisassemble(), parse_fx10_fxlc(), parse_fx10_shader(), and preprocess_shader().

D3DCreateLinker()

HRESULT WINAPI D3DCreateLinker

(

ID3D11Linker **

linker

)

Definition at line 790 of file compiler.c.

{
    FIXME("linker %p stub!\n", linker);
    return E_NOTIMPL;
}

D3DDisassemble()

HRESULT WINAPI D3DDisassemble	(	const void *	data,
		SIZE_T	data_size,
		UINT	flags,
		const char *	comments,
		ID3DBlob **	disassembly
	)

Definition at line 668 of file compiler.c.

{
    struct vkd3d_shader_compile_info compile_info;
    enum vkd3d_shader_source_type source_type;
    struct vkd3d_shader_code asm_code;
    const char *ptr = data;
    char *messages;
    HRESULT hr;
    int ret;
 
    TRACE("data %p, size %Iu, flags %#x, comments %p, disassembly %p.\n",
            data, size, flags, comments, disassembly);
 
    if (flags)
        FIXME("Ignoring flags %#x.\n", flags);
 
    if (comments)
        FIXME("Ignoring comments %s.\n", debugstr_a(comments));
 
#if D3D_COMPILER_VERSION >= 46
    if (!size)
        return E_INVALIDARG;
#endif
 
    if (size >= 4 && read_u32(&ptr) == TAG_DXBC)
        source_type = VKD3D_SHADER_SOURCE_DXBC_TPF;
    else
        source_type = VKD3D_SHADER_SOURCE_D3D_BYTECODE;
 
    compile_info.type = VKD3D_SHADER_STRUCTURE_TYPE_COMPILE_INFO;
    compile_info.next = NULL;
    compile_info.source.code = data;
    compile_info.source.size = size;
    compile_info.source_type = source_type;
    compile_info.target_type = VKD3D_SHADER_TARGET_D3D_ASM;
    compile_info.options = NULL;
    compile_info.option_count = 0;
    compile_info.log_level = VKD3D_SHADER_LOG_INFO;
    compile_info.source_name = NULL;
 
    ret = vkd3d_shader_compile(&compile_info, &asm_code, &messages);
 
    if (ret)
        ERR("Failed to disassemble shader, vkd3d result %d.\n", ret);
 
    if (messages)
    {
        if (*messages && ERR_ON(d3dcompiler))
        {
            const char *ptr = messages;
            const char *line;
 
            ERR("Shader log:\n");
            while ((line = get_line(&ptr)))
            {
                ERR("    %.*s", (int)(ptr - line), line);
            }
            ERR("\n");
        }
 
        vkd3d_shader_free_messages(messages);
    }
 
    if (ret)
        return hresult_from_vkd3d_result(ret);
 
    if (SUCCEEDED(hr = D3DCreateBlob(asm_code.size, disassembly)))
        memcpy(ID3D10Blob_GetBufferPointer(*disassembly), asm_code.code, asm_code.size);
 
    vkd3d_shader_free_shader_code(&asm_code);
 
    return hr;
}

Referenced by D3DXDisassembleShader(), and test_disassemble_shader().

D3DGetBlobPart()

HRESULT WINAPI D3DGetBlobPart	(	const void *	data,
		SIZE_T	data_size,
		D3D_BLOB_PART	part,
		UINT	flags,
		ID3DBlob **	blob
	)

Definition at line 413 of file blob.c.

{
    TRACE("data %p, data_size %Iu, part %s, flags %#x, blob %p.\n", data,
           data_size, debug_d3dcompiler_d3d_blob_part(part), flags, blob);
 
    return d3dcompiler_get_blob_part(data, data_size, part, flags, blob);
}

D3DGetDebugInfo()

HRESULT WINAPI D3DGetDebugInfo	(	const void *	data,
		SIZE_T	data_size,
		ID3DBlob **	blob
	)

Definition at line 442 of file blob.c.

{
    TRACE("data %p, data_size %Iu, blob %p.\n", data, data_size, blob);
 
    return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_DEBUG_INFO, 0, blob);
}

D3DGetInputAndOutputSignatureBlob()

HRESULT WINAPI D3DGetInputAndOutputSignatureBlob	(	const void *	data,
		SIZE_T	data_size,
		ID3DBlob **	blob
	)

Definition at line 435 of file blob.c.

{
    TRACE("data %p, data_size %Iu, blob %p.\n", data, data_size, blob);
 
    return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB, 0, blob);
}

D3DGetInputSignatureBlob()

HRESULT WINAPI D3DGetInputSignatureBlob	(	const void *	data,
		SIZE_T	data_size,
		ID3DBlob **	blob
	)

Definition at line 421 of file blob.c.

{
    TRACE("data %p, data_size %Iu, blob %p.\n", data, data_size, blob);
 
    return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_INPUT_SIGNATURE_BLOB, 0, blob);
}

Referenced by parse_fx10_shader().

D3DGetOutputSignatureBlob()

HRESULT WINAPI D3DGetOutputSignatureBlob	(	const void *	data,
		SIZE_T	data_size,
		ID3DBlob **	blob
	)

Definition at line 428 of file blob.c.

{
    TRACE("data %p, data_size %Iu, blob %p.\n", data, data_size, blob);
 
    return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_OUTPUT_SIGNATURE_BLOB, 0, blob);
}

D3DLoadModule()

HRESULT WINAPI D3DLoadModule	(	const void *	data,
		SIZE_T	size,
		ID3D11Module **	module
	)

Definition at line 796 of file compiler.c.

{
    FIXME("data %p, size %Iu, module %p stub!\n", data, size, module);
    return E_NOTIMPL;
}

D3DPreprocess()

HRESULT WINAPI D3DPreprocess	(	const void *	data,
		SIZE_T	size,
		const char *	filename,
		const D3D_SHADER_MACRO *	defines,
		ID3DInclude *	include,
		ID3DBlob **	shader,
		ID3DBlob **	error_messages
	)

Definition at line 652 of file compiler.c.

{
    TRACE("data %p, size %Iu, filename %s, defines %p, include %p, shader %p, error_messages %p.\n",
          data, size, debugstr_a(filename), defines, include, shader, error_messages);
 
    if (!data)
        return E_INVALIDARG;
 
    if (shader) *shader = NULL;
    if (error_messages) *error_messages = NULL;
 
    return preprocess_shader(data, size, filename, defines, include, shader, error_messages);
}

Referenced by call_D3DPreprocess(), d3dpreprocess_test(), D3DX10PreprocessShaderFromMemory(), D3DXPreprocessShader(), and D3DXPreprocessShaderFromFileW().

D3DReadFileToBlob()

HRESULT WINAPI D3DReadFileToBlob	(	const WCHAR *	filename,
		ID3DBlob **	contents
	)

Definition at line 456 of file blob.c.

{
    struct d3dcompiler_blob *object;
    SIZE_T data_size;
    DWORD read_size;
    HANDLE file;
    HRESULT hr;
 
    TRACE("filename %s, contents %p.\n", debugstr_w(filename), contents);
 
    file = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (file == INVALID_HANDLE_VALUE)
        return HRESULT_FROM_WIN32(GetLastError());
 
    data_size = GetFileSize(file, NULL);
    if (data_size == INVALID_FILE_SIZE)
    {
        CloseHandle(file);
        return HRESULT_FROM_WIN32(GetLastError());
    }
 
    if (!(object = calloc(1, sizeof(*object))))
    {
        CloseHandle(file);
        return E_OUTOFMEMORY;
    }
 
    if (FAILED(hr = d3dcompiler_blob_init(object, data_size)))
    {
        WARN("Failed to initialise blob, hr %#lx.\n", hr);
        CloseHandle(file);
        free(object);
        return hr;
    }
 
    if (!ReadFile(file, object->data, data_size, &read_size, NULL) || (read_size != data_size))
    {
        WARN("Failed to read file contents.\n");
        CloseHandle(file);
        free(object->data);
        free(object);
        return E_FAIL;
    }
    CloseHandle(file);
    object->size = read_size;
 
    *contents = &object->ID3DBlob_iface;
 
    TRACE("Returning ID3DBlob %p.\n", *contents);
 
    return S_OK;
}

D3DReflect()

HRESULT WINAPI D3DReflect	(	const void *	data,
		SIZE_T	data_size,
		REFIID	riid,
		void **	reflector
	)

Referenced by call_reflect(), test_reflection(), and test_semantic_reflection().

D3DStripShader()

HRESULT WINAPI D3DStripShader	(	const void *	data,
		SIZE_T	data_size,
		UINT	flags,
		ID3DBlob **	blob
	)

Definition at line 449 of file blob.c.

{
    TRACE("data %p, data_size %Iu, flags %#x, blob %p.\n", data, data_size, flags, blob);
 
    return d3dcompiler_strip_shader(data, data_size, flags, blob);
}

D3DWriteBlobToFile()

HRESULT WINAPI D3DWriteBlobToFile	(	ID3DBlob *	blob,
		const WCHAR *	filename,
		BOOL	overwrite
	)

Definition at line 509 of file blob.c.

{
    DWORD written_size;
    SIZE_T data_size;
    HANDLE file;
    BOOL ret;
 
    TRACE("blob %p, filename %s, overwrite %#x.\n", blob, debugstr_w(filename), overwrite);
 
    file = CreateFileW(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL, overwrite ? CREATE_ALWAYS : CREATE_NEW,
            FILE_ATTRIBUTE_NORMAL, NULL);
    if (file == INVALID_HANDLE_VALUE)
        return HRESULT_FROM_WIN32(GetLastError());
 
    data_size = ID3D10Blob_GetBufferSize(blob);
    ret = WriteFile(file, ID3D10Blob_GetBufferPointer(blob), data_size, &written_size, NULL);
    CloseHandle(file);
    if (!ret || data_size != written_size)
    {
        WARN("Failed to write blob contents.\n");
        return E_FAIL;
    }
 
    return S_OK;
}

Variable Documentation

D3DCOMPILER_DLL_W

const WCHAR D3DCOMPILER_DLL_W[] = {'d','3','d','c','o','m','p','i','l','e','r','_','4','7','.','d','l','l',0}

static

Definition at line 32 of file d3dcompiler.h.

Referenced by load_d3dassemble_once().