d3dx11async.h File Reference

#include "d3dx11.h"

Include dependency graph for d3dx11async.h:

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

Go to the source code of this file.

Functions
HRESULT WINAPI	D3DX11CreateAsyncFileLoaderA (const char *file_name, ID3DX11DataLoader **loader)
HRESULT WINAPI	D3DX11CreateAsyncFileLoaderW (const WCHAR *file_name, ID3DX11DataLoader **loader)
HRESULT WINAPI	D3DX11CreateAsyncResourceLoaderA (HMODULE module, const char *resource, ID3DX11DataLoader **loader)
HRESULT WINAPI	D3DX11CreateAsyncResourceLoaderW (HMODULE module, const WCHAR *resource, ID3DX11DataLoader **loader)
HRESULT WINAPI	D3DX11CreateAsyncMemoryLoader (const void *data, SIZE_T data_size, ID3DX11DataLoader **loader)
HRESULT WINAPI	D3DX11CompileFromMemory (const char *data, SIZE_T data_size, const char *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *entry_point, const char *target, UINT sflags, UINT eflags, ID3DX11ThreadPump *pump, ID3D10Blob **shader, ID3D10Blob **error_messages, HRESULT *hresult)
HRESULT WINAPI	D3DX11CompileFromFileA (const char *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *entry_point, const char *target, UINT sflags, UINT eflags, ID3DX11ThreadPump *pump, ID3D10Blob **shader, ID3D10Blob **error_messages, HRESULT *hresult)
HRESULT WINAPI	D3DX11CompileFromFileW (const WCHAR *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *entry_point, const char *target, UINT sflags, UINT eflags, ID3DX11ThreadPump *pump, ID3D10Blob **shader, ID3D10Blob **error_messages, HRESULT *hresult)

Function Documentation

D3DX11CompileFromFileA()

HRESULT WINAPI D3DX11CompileFromFileA	(	const char *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3D10Include *	include,
		const char *	entry_point,
		const char *	target,
		UINT	sflags,
		UINT	eflags,
		ID3DX11ThreadPump *	pump,
		ID3D10Blob **	shader,
		ID3D10Blob **	error_messages,
		HRESULT *	hresult
	)

Definition at line 235 of file async.c.

{
    WCHAR filename_w[MAX_PATH];
 
    TRACE("filename %s, defines %p, include %p, entry_point %s, target %s, sflags %#x, "
            "eflags %#x, pump %p, shader %p, error_messages %p, hresult %p.\n",
            debugstr_a(filename), defines, include, debugstr_a(entry_point), debugstr_a(target),
            sflags, eflags, pump, shader, error_messages, hresult);
 
    MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, ARRAY_SIZE(filename_w));
 
    return D3DX11CompileFromFileW(filename_w, defines, include, entry_point, target,
            sflags, eflags, pump, shader, error_messages, hresult);
}

D3DX11CompileFromFileW()

HRESULT WINAPI D3DX11CompileFromFileW	(	const WCHAR *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3D10Include *	include,
		const char *	entry_point,
		const char *	target,
		UINT	sflags,
		UINT	eflags,
		ID3DX11ThreadPump *	pump,
		ID3D10Blob **	shader,
		ID3D10Blob **	error_messages,
		HRESULT *	hresult
	)

Definition at line 252 of file async.c.

{
    HRESULT hr;
 
    TRACE("filename %s, defines %p, include %p, entry_point %s, target %s, sflags %#x, "
            "eflags %#x, pump %p, shader %p, error_messages %p, hresult %p.\n",
            debugstr_w(filename), defines, include, debugstr_a(entry_point), debugstr_a(target),
            sflags, eflags, pump, shader, error_messages, hresult);
 
    if (pump)
        FIXME("Unimplemented ID3DX11ThreadPump handling.\n");
 
    if (!include)
        include = D3D_COMPILE_STANDARD_FILE_INCLUDE;
 
    hr = D3DCompileFromFile(filename, defines, include, entry_point, target, sflags, eflags, shader, error_messages);
    if (hresult)
        *hresult = hr;
 
    return hr;
}

Referenced by D3DX11CompileFromFileA().

D3DX11CompileFromMemory()

HRESULT WINAPI D3DX11CompileFromMemory	(	const char *	data,
		SIZE_T	data_size,
		const char *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3D10Include *	include,
		const char *	entry_point,
		const char *	target,
		UINT	sflags,
		UINT	eflags,
		ID3DX11ThreadPump *	pump,
		ID3D10Blob **	shader,
		ID3D10Blob **	error_messages,
		HRESULT *	hresult
	)

Definition at line 217 of file async.c.

{
    TRACE("data %s, data_size %Iu, filename %s, defines %p, include %p, entry_point %s, target %s, "
            "sflags %#x, eflags %#x, pump %p, shader %p, error_messages %p, hresult %p.\n",
            debugstr_an(data, data_size), data_size, debugstr_a(filename), defines, include,
            debugstr_a(entry_point), debugstr_a(target), sflags, eflags, pump, shader,
            error_messages, hresult);
 
    if (pump)
        FIXME("Unimplemented ID3DX11ThreadPump handling.\n");
 
    return D3DCompile(data, data_size, filename, defines, include, entry_point, target,
            sflags, eflags, shader, error_messages);
}

D3DX11CreateAsyncFileLoaderA()

HRESULT WINAPI D3DX11CreateAsyncFileLoaderA	(	const char *	file_name,
		ID3DX11DataLoader **	loader
	)

Definition at line 298 of file async.c.

{
    WCHAR *filename_w;
    HRESULT hr;
    int len;
 
    TRACE("filename %s, loader %p.\n", debugstr_a(filename), loader);
 
    if (!filename || !loader)
        return E_FAIL;
 
    len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
    filename_w = malloc(len * sizeof(*filename_w));
    MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 
    hr = D3DX11CreateAsyncFileLoaderW(filename_w, loader);
 
    free(filename_w);
 
    return hr;
}

D3DX11CreateAsyncFileLoaderW()

HRESULT WINAPI D3DX11CreateAsyncFileLoaderW	(	const WCHAR *	file_name,
		ID3DX11DataLoader **	loader
	)

Definition at line 320 of file async.c.

{
    struct asyncdataloader *object;
 
    TRACE("filename %s, loader %p.\n", debugstr_w(filename), loader);
 
    if (!filename || !loader)
        return E_FAIL;
 
    object = calloc(1, sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    object->ID3DX11DataLoader_iface.lpVtbl = &filedataloadervtbl;
    object->u.file.path = malloc((lstrlenW(filename) + 1) * sizeof(WCHAR));
    if (!object->u.file.path)
    {
        free(object);
        return E_OUTOFMEMORY;
    }
    lstrcpyW(object->u.file.path, filename);
    object->data = NULL;
    object->size = 0;
 
    *loader = &object->ID3DX11DataLoader_iface;
 
    return S_OK;
}

Referenced by D3DX11CreateAsyncFileLoaderA().

D3DX11CreateAsyncMemoryLoader()

HRESULT WINAPI D3DX11CreateAsyncMemoryLoader	(	const void *	data,
		SIZE_T	data_size,
		ID3DX11DataLoader **	loader
	)

Definition at line 276 of file async.c.

{
    struct asyncdataloader *object;
 
    TRACE("data %p, data_size %Iu, loader %p.\n", data, data_size, loader);
 
    if (!data || !loader)
        return E_FAIL;
 
    object = calloc(1, sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    object->ID3DX11DataLoader_iface.lpVtbl = &memorydataloadervtbl;
    object->data = (void *)data;
    object->size = data_size;
 
    *loader = &object->ID3DX11DataLoader_iface;
 
    return S_OK;
}

D3DX11CreateAsyncResourceLoaderA()

HRESULT WINAPI D3DX11CreateAsyncResourceLoaderA	(	HMODULE	module,
		const char *	resource,
		ID3DX11DataLoader **	loader
	)

Definition at line 349 of file async.c.

{
    struct asyncdataloader *object;
    HRSRC rsrc;
 
    TRACE("module %p, resource %s, loader %p.\n", module, debugstr_a(resource), loader);
 
    if (!loader)
        return E_FAIL;
 
    object = calloc(1, sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    if (!(rsrc = FindResourceA(module, resource, (const char *)RT_RCDATA)))
    {
        WARN("Failed to find resource.\n");
        free(object);
        return D3DX11_ERR_INVALID_DATA;
    }
 
    object->ID3DX11DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
    object->u.resource.module = module;
    object->u.resource.rsrc = rsrc;
    object->data = NULL;
    object->size = 0;
 
    *loader = &object->ID3DX11DataLoader_iface;
 
    return S_OK;
}

D3DX11CreateAsyncResourceLoaderW()

HRESULT WINAPI D3DX11CreateAsyncResourceLoaderW	(	HMODULE	module,
		const WCHAR *	resource,
		ID3DX11DataLoader **	loader
	)

Definition at line 381 of file async.c.

{
    struct asyncdataloader *object;
    HRSRC rsrc;
 
    TRACE("module %p, resource %s, loader %p.\n", module, debugstr_w(resource), loader);
 
    if (!loader)
        return E_FAIL;
 
    object = calloc(1, sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    if (!(rsrc = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
    {
        WARN("Failed to find resource.\n");
        free(object);
        return D3DX11_ERR_INVALID_DATA;
    }
 
    object->ID3DX11DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
    object->u.resource.module = module;
    object->u.resource.rsrc = rsrc;
    object->data = NULL;
    object->size = 0;
 
    *loader = &object->ID3DX11DataLoader_iface;
 
    return S_OK;
}