d3dx10async.h File Reference

#include "d3dx10.h"

Include dependency graph for d3dx10async.h:

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

Go to the source code of this file.

Functions
HRESULT WINAPI	D3DX10CompileFromMemory (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, ID3DX10ThreadPump *pump, ID3D10Blob **shader, ID3D10Blob **error_messages, HRESULT *hresult)
HRESULT WINAPI	D3DX10CreateEffectFromFileA (const char *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device, ID3D10EffectPool *effectpool, ID3DX10ThreadPump *pump, ID3D10Effect **effect, ID3D10Blob **errors, HRESULT *hresult)
HRESULT WINAPI	D3DX10CreateEffectFromFileW (const WCHAR *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device, ID3D10EffectPool *effectpool, ID3DX10ThreadPump *pump, ID3D10Effect **effect, ID3D10Blob **errors, HRESULT *hresult)
HRESULT WINAPI	D3DX10CreateEffectFromMemory (const void *data, SIZE_T datasize, const char *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device, ID3D10EffectPool *effectpool, ID3DX10ThreadPump *pump, ID3D10Effect **effect, ID3D10Blob **errors, HRESULT *hresult)
HRESULT WINAPI	D3DX10CreateEffectPoolFromFileA (const char *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device, ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, ID3D10Blob **errors, HRESULT *hresult)
HRESULT WINAPI	D3DX10CreateEffectPoolFromFileW (const WCHAR *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device, ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, ID3D10Blob **errors, HRESULT *hresult)
HRESULT WINAPI	D3DX10CreateEffectPoolFromMemory (const void *data, SIZE_T datasize, const char *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *profile, UINT hlslflags, UINT fxflags, ID3D10Device *device, ID3DX10ThreadPump *pump, ID3D10EffectPool **effectpool, ID3D10Blob **errors, HRESULT *hresult)
HRESULT WINAPI	D3DX10PreprocessShaderFromMemory (const char *data, SIZE_T data_size, const char *filename, const D3D10_SHADER_MACRO *defines, ID3DInclude *include, ID3DX10ThreadPump *pump, ID3D10Blob **shader_text, ID3D10Blob **errors, HRESULT *hresult)
HRESULT WINAPI	D3DX10CreateEffectFromResourceA (HMODULE module, const char *resource_name, const char *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *profile, UINT shader_flags, UINT effect_flags, ID3D10Device *device, ID3D10EffectPool *effect_pool, ID3DX10ThreadPump *pump, ID3D10Effect **effect, ID3D10Blob **errors, HRESULT *hresult)
HRESULT WINAPI	D3DX10CreateEffectFromResourceW (HMODULE module, const WCHAR *resource_name, const WCHAR *filename, const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *profile, UINT shader_flags, UINT effect_flags, ID3D10Device *device, ID3D10EffectPool *effect_pool, ID3DX10ThreadPump *pump, ID3D10Effect **effect, ID3D10Blob **errors, HRESULT *hresult)
HRESULT WINAPI	D3DX10CreateAsyncFileLoaderW (const WCHAR *filename, ID3DX10DataLoader **loader)
HRESULT WINAPI	D3DX10CreateAsyncFileLoaderA (const char *filename, ID3DX10DataLoader **loader)
HRESULT WINAPI	D3DX10CreateAsyncMemoryLoader (const void *data, SIZE_T datasize, ID3DX10DataLoader **loader)
HRESULT WINAPI	D3DX10CreateAsyncResourceLoaderA (HMODULE module, const char *resource, ID3DX10DataLoader **loader)
HRESULT WINAPI	D3DX10CreateAsyncResourceLoaderW (HMODULE module, const WCHAR *resource, ID3DX10DataLoader **loader)
HRESULT WINAPI	D3DX10CreateAsyncTextureProcessor (ID3D10Device *device, D3DX10_IMAGE_LOAD_INFO *info, ID3DX10DataProcessor **processor)
HRESULT WINAPI	D3DX10CreateAsyncTextureInfoProcessor (D3DX10_IMAGE_INFO *info, ID3DX10DataProcessor **processor)

Function Documentation

D3DX10CompileFromMemory()

HRESULT WINAPI D3DX10CompileFromMemory	(	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,
		ID3DX10ThreadPump *	pump,
		ID3D10Blob **	shader,
		ID3D10Blob **	error_messages,
		HRESULT *	hresult
	)

Definition at line 381 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 ID3DX10ThreadPump handling.\n");
 
    return D3DCompile(data, data_size, filename, defines, include, entry_point, target,
            sflags, eflags, shader, error_messages);
}

D3DX10CreateAsyncFileLoaderA()

HRESULT WINAPI D3DX10CreateAsyncFileLoaderA	(	const char *	filename,
		ID3DX10DataLoader **	loader
	)

Definition at line 445 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 = D3DX10CreateAsyncFileLoaderW(filename_w, loader);
 
    free(filename_w);
 
    return hr;
}

D3DX10CreateAsyncFileLoaderW()

HRESULT WINAPI D3DX10CreateAsyncFileLoaderW	(	const WCHAR *	filename,
		ID3DX10DataLoader **	loader
	)

Definition at line 467 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->ID3DX10DataLoader_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->ID3DX10DataLoader_iface;
 
    return S_OK;
}

Referenced by D3DX10CreateAsyncFileLoaderA(), D3DX10CreateTextureFromFileW(), and D3DX10GetImageInfoFromFileW().

D3DX10CreateAsyncMemoryLoader()

HRESULT WINAPI D3DX10CreateAsyncMemoryLoader	(	const void *	data,
		SIZE_T	datasize,
		ID3DX10DataLoader **	loader
	)

Definition at line 423 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->ID3DX10DataLoader_iface.lpVtbl = &memorydataloadervtbl;
    object->data = (void *)data;
    object->size = data_size;
 
    *loader = &object->ID3DX10DataLoader_iface;
 
    return S_OK;
}

Referenced by D3DX10CreateTextureFromMemory(), and D3DX10GetImageInfoFromMemory().

D3DX10CreateAsyncResourceLoaderA()

HRESULT WINAPI D3DX10CreateAsyncResourceLoaderA	(	HMODULE	module,
		const char *	resource,
		ID3DX10DataLoader **	loader
	)

Definition at line 496 of file async.c.

{
    struct asyncdataloader *object;
    HRSRC rsrc;
    HRESULT hr;
 
    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 (FAILED((hr = load_resource_initA(module, resource, &rsrc))))
    {
        free(object);
        return hr;
    }
 
    object->ID3DX10DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
    object->u.resource.module = module;
    object->u.resource.rsrc = rsrc;
    object->data = NULL;
    object->size = 0;
 
    *loader = &object->ID3DX10DataLoader_iface;
 
    return S_OK;
}

Referenced by D3DX10CreateTextureFromResourceA(), and D3DX10GetImageInfoFromResourceA().

D3DX10CreateAsyncResourceLoaderW()

HRESULT WINAPI D3DX10CreateAsyncResourceLoaderW	(	HMODULE	module,
		const WCHAR *	resource,
		ID3DX10DataLoader **	loader
	)

Definition at line 528 of file async.c.

{
    struct asyncdataloader *object;
    HRSRC rsrc;
    HRESULT hr;
 
    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 (FAILED((hr = load_resource_initW(module, resource, &rsrc))))
    {
        free(object);
        return hr;
    }
 
    object->ID3DX10DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
    object->u.resource.module = module;
    object->u.resource.rsrc = rsrc;
    object->data = NULL;
    object->size = 0;
 
    *loader = &object->ID3DX10DataLoader_iface;
 
    return S_OK;
}

Referenced by D3DX10CreateTextureFromResourceW(), and D3DX10GetImageInfoFromResourceW().

D3DX10CreateAsyncTextureInfoProcessor()

HRESULT WINAPI D3DX10CreateAsyncTextureInfoProcessor	(	D3DX10_IMAGE_INFO *	info,
		ID3DX10DataProcessor **	processor
	)

Definition at line 560 of file async.c.

{
    struct texture_info_processor *object;
 
    TRACE("info %p, processor %p.\n", info, processor);
 
    if (!processor)
        return E_INVALIDARG;
 
    object = malloc(sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    object->ID3DX10DataProcessor_iface.lpVtbl = &texture_info_processor_vtbl;
    object->info = info;
 
    *processor = &object->ID3DX10DataProcessor_iface;
    return S_OK;
}

Referenced by D3DX10GetImageInfoFromFileW(), D3DX10GetImageInfoFromMemory(), D3DX10GetImageInfoFromResourceA(), and D3DX10GetImageInfoFromResourceW().

D3DX10CreateAsyncTextureProcessor()

HRESULT WINAPI D3DX10CreateAsyncTextureProcessor	(	ID3D10Device *	device,
		D3DX10_IMAGE_LOAD_INFO *	info,
		ID3DX10DataProcessor **	processor
	)

Definition at line 580 of file async.c.

{
    struct texture_processor *object;
 
    TRACE("device %p, load_info %p, processor %p.\n", device, load_info, processor);
 
    if (!device || !processor)
        return E_INVALIDARG;
 
    object = calloc(1, sizeof(*object));
    if (!object)
        return E_OUTOFMEMORY;
 
    object->ID3DX10DataProcessor_iface.lpVtbl = &texture_processor_vtbl;
    object->device = device;
    ID3D10Device_AddRef(device);
    init_load_info(load_info, &object->load_info);
 
    *processor = &object->ID3DX10DataProcessor_iface;
    return S_OK;
}

Referenced by D3DX10CreateTextureFromFileW(), D3DX10CreateTextureFromMemory(), D3DX10CreateTextureFromResourceA(), and D3DX10CreateTextureFromResourceW().

D3DX10CreateEffectFromFileA()

HRESULT WINAPI D3DX10CreateEffectFromFileA	(	const char *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3D10Include *	include,
		const char *	profile,
		UINT	hlslflags,
		UINT	fxflags,
		ID3D10Device *	device,
		ID3D10EffectPool *	effectpool,
		ID3DX10ThreadPump *	pump,
		ID3D10Effect **	effect,
		ID3D10Blob **	errors,
		HRESULT *	hresult
	)

Definition at line 130 of file compiler.c.

{
    WCHAR *filenameW;
    HRESULT hr;
    int len;
 
    TRACE("filename %s, defines %p, include %p, profile %s, shader_flags %#x, effect_flags %#x, "
            "device %p, effect_pool %p, pump %p, effect %p, errors %p, hresult %p.\n",
            debugstr_a(filename), defines, include, debugstr_a(profile), shader_flags, effect_flags,
            device, effect_pool, pump, effect, errors, hresult);
 
    if (!filename)
        return E_FAIL;
 
    len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
    if (!(filenameW = malloc(len * sizeof(*filenameW))))
        return E_OUTOFMEMORY;
    MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, len);
 
    hr = D3DX10CreateEffectFromFileW(filenameW, defines, include, profile, shader_flags,
            effect_flags, device, effect_pool, pump, effect, errors, hresult);
    free(filenameW);
 
    return hr;
}

D3DX10CreateEffectFromFileW()

HRESULT WINAPI D3DX10CreateEffectFromFileW	(	const WCHAR *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3D10Include *	include,
		const char *	profile,
		UINT	hlslflags,
		UINT	fxflags,
		ID3D10Device *	device,
		ID3D10EffectPool *	effectpool,
		ID3DX10ThreadPump *	pump,
		ID3D10Effect **	effect,
		ID3D10Blob **	errors,
		HRESULT *	hresult
	)

Definition at line 95 of file compiler.c.

{
    char filename_a[MAX_PATH];
    void *buffer = NULL;
    DWORD size = 0;
    HRESULT hr;
 
    TRACE("filename %s, defines %p, include %p, profile %s, shader_flags %#x, effect_flags %#x, "
            "device %p, effect_pool %p, pump %p, effect %p, errors %p, hresult %p.\n",
            debugstr_w(filename), defines, include, debugstr_a(profile), shader_flags, effect_flags,
            device, effect_pool, pump, effect, errors, hresult);
 
    if (!filename)
        return E_FAIL;
 
    if (pump)
        FIXME("Asynchronous mode is not supported.\n");
 
    if (!include)
        include = D3D_COMPILE_STANDARD_FILE_INCLUDE;
 
    if (SUCCEEDED((hr = load_file(filename, &buffer, &size))))
    {
        WideCharToMultiByte(CP_ACP, 0, filename, -1, filename_a, sizeof(filename_a), NULL, NULL);
        hr = create_effect(buffer, size, filename_a, defines, include, profile,
                shader_flags, effect_flags, device, effect_pool, effect, errors);
        free(buffer);
    }
 
    return hr;
}

Referenced by D3DX10CreateEffectFromFileA().

D3DX10CreateEffectFromMemory()

HRESULT WINAPI D3DX10CreateEffectFromMemory	(	const void *	data,
		SIZE_T	datasize,
		const char *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3D10Include *	include,
		const char *	profile,
		UINT	hlslflags,
		UINT	fxflags,
		ID3D10Device *	device,
		ID3D10EffectPool *	effectpool,
		ID3DX10ThreadPump *	pump,
		ID3D10Effect **	effect,
		ID3D10Blob **	errors,
		HRESULT *	hresult
	)

Definition at line 75 of file compiler.c.

{
    TRACE("data %p, datasize %Iu, filename %s, defines %p, include %p, profile %s, shader_flags %#x,"
            "effect_flags %#x, device %p, effect_pool %p, pump %p, effect %p, errors %p, hresult %p.\n",
            data, datasize, debugstr_a(filename), defines, include, debugstr_a(profile),
            shader_flags, effect_flags, device, effect_pool, pump, effect, errors, hresult);
 
    if (pump)
        FIXME("Asynchronous mode is not supported.\n");
 
    if (!include)
        include = D3D_COMPILE_STANDARD_FILE_INCLUDE;
 
    return create_effect(data, datasize, filename, defines, include, profile,
            shader_flags, effect_flags, device, effect_pool, effect, errors);
}

D3DX10CreateEffectFromResourceA()

HRESULT WINAPI D3DX10CreateEffectFromResourceA	(	HMODULE	module,
		const char *	resource_name,
		const char *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3D10Include *	include,
		const char *	profile,
		UINT	shader_flags,
		UINT	effect_flags,
		ID3D10Device *	device,
		ID3D10EffectPool *	effect_pool,
		ID3DX10ThreadPump *	pump,
		ID3D10Effect **	effect,
		ID3D10Blob **	errors,
		HRESULT *	hresult
	)

Definition at line 159 of file compiler.c.

{
    void *data;
    DWORD size;
    HRESULT hr;
 
    TRACE("module %p, resource_name %s, filename %s, defines %p, include %p, profile %s, "
            "shader_flags %#x, effect_flags %#x, device %p, effect_pool %p, pump %p, effect %p, "
            "errors %p, hresult %p.\n", module, debugstr_a(resource_name), debugstr_a(filename),
            defines, include, debugstr_a(profile), shader_flags, effect_flags,
            device, effect_pool, pump, effect, errors, hresult);
 
    hr = load_resourceA(module, resource_name, &data, &size);
    if (FAILED(hr))
        return hr;
 
    return create_effect(data, size, filename, defines, include, profile,
            shader_flags, effect_flags, device, effect_pool, effect, errors);
}

D3DX10CreateEffectFromResourceW()

HRESULT WINAPI D3DX10CreateEffectFromResourceW	(	HMODULE	module,
		const WCHAR *	resource_name,
		const WCHAR *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3D10Include *	include,
		const char *	profile,
		UINT	shader_flags,
		UINT	effect_flags,
		ID3D10Device *	device,
		ID3D10EffectPool *	effect_pool,
		ID3DX10ThreadPump *	pump,
		ID3D10Effect **	effect,
		ID3D10Blob **	errors,
		HRESULT *	hresult
	)

Definition at line 183 of file compiler.c.

{
    char *filename = NULL;
    void *data;
    DWORD size;
    HRESULT hr;
    int len;
 
    TRACE("module %p, resource_name %s, filename %s, defines %p, include %p, profile %s, "
            "shader_flags %#x, effect_flags %#x, device %p, effect_pool %p, pump %p, effect %p, "
            "errors %p, hresult %p.\n", module, debugstr_w(resource_name), debugstr_w(filenameW),
            defines, include, debugstr_a(profile), shader_flags, effect_flags,
            device, effect_pool, pump, effect, errors, hresult);
 
    hr = load_resourceW(module, resource_name, &data, &size);
    if (FAILED(hr))
        return hr;
 
    if (filenameW)
    {
        len = WideCharToMultiByte(CP_ACP, 0, filenameW, -1, NULL, 0, NULL, NULL);
        if (!(filename = malloc(len)))
            return E_OUTOFMEMORY;
        WideCharToMultiByte(CP_ACP, 0, filenameW, -1, filename, len, NULL, NULL);
    }
 
    hr = create_effect(data, size, filename, defines, include, profile,
            shader_flags, effect_flags, device, effect_pool, effect, errors);
    free(filename);
    return hr;
}

D3DX10CreateEffectPoolFromFileA()

HRESULT WINAPI D3DX10CreateEffectPoolFromFileA	(	const char *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3D10Include *	include,
		const char *	profile,
		UINT	hlslflags,
		UINT	fxflags,
		ID3D10Device *	device,
		ID3DX10ThreadPump *	pump,
		ID3D10EffectPool **	effectpool,
		ID3D10Blob **	errors,
		HRESULT *	hresult
	)

Definition at line 399 of file async.c.

{
    FIXME("filename %s, defines %p, include %p, profile %s, hlslflags %#x, fxflags %#x, device %p, "
            "pump %p, effectpool %p, errors %p, hresult %p, stub!\n",
            debugstr_a(filename), defines, include, debugstr_a(profile), hlslflags, fxflags, device,
            pump, effectpool, errors, hresult);
 
    return E_NOTIMPL;
}

D3DX10CreateEffectPoolFromFileW()

HRESULT WINAPI D3DX10CreateEffectPoolFromFileW	(	const WCHAR *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3D10Include *	include,
		const char *	profile,
		UINT	hlslflags,
		UINT	fxflags,
		ID3D10Device *	device,
		ID3DX10ThreadPump *	pump,
		ID3D10EffectPool **	effectpool,
		ID3D10Blob **	errors,
		HRESULT *	hresult
	)

Definition at line 411 of file async.c.

{
    FIXME("filename %s, defines %p, include %p, profile %s, hlslflags %#x, fxflags %#x, device %p, "
            "pump %p, effectpool %p, errors %p, hresult %p, stub!\n",
            debugstr_w(filename), defines, include, debugstr_a(profile), hlslflags, fxflags, device,
            pump, effectpool, errors, hresult);
 
    return E_NOTIMPL;
}

D3DX10CreateEffectPoolFromMemory()

HRESULT WINAPI D3DX10CreateEffectPoolFromMemory	(	const void *	data,
		SIZE_T	datasize,
		const char *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3D10Include *	include,
		const char *	profile,
		UINT	hlslflags,
		UINT	fxflags,
		ID3D10Device *	device,
		ID3DX10ThreadPump *	pump,
		ID3D10EffectPool **	effectpool,
		ID3D10Blob **	errors,
		HRESULT *	hresult
	)

Definition at line 51 of file d3dx10_43_main.c.

{
    FIXME("data %p, datasize %Iu, filename %s, defines %p, include %p, profile %s, hlslflags %#x, fxflags %#x, "
            "device %p, pump %p, effectpool %p, errors %p, hresult %p.\n",
            data, datasize, debugstr_a(filename), defines, include, debugstr_a(profile), hlslflags, fxflags, device,
            pump, effectpool, errors, hresult);
 
    return E_NOTIMPL;
}

D3DX10PreprocessShaderFromMemory()

HRESULT WINAPI D3DX10PreprocessShaderFromMemory	(	const char *	data,
		SIZE_T	data_size,
		const char *	filename,
		const D3D10_SHADER_MACRO *	defines,
		ID3DInclude *	include,
		ID3DX10ThreadPump *	pump,
		ID3D10Blob **	shader_text,
		ID3D10Blob **	errors,
		HRESULT *	hresult
	)

Definition at line 219 of file compiler.c.

{
    HRESULT hr;
 
    TRACE("data %s, data_size %Iu, filename %s, defines %p, include %p, pump %p, shader_text %p, "
            "errors %p, hresult %p.\n",
            debugstr_an(data, data_size), data_size, debugstr_a(filename), defines, include, pump,
            shader_text, errors, hresult);
 
    if (!data)
        return E_FAIL;
 
    if (pump)
        FIXME("Unimplemented ID3DX10ThreadPump handling.\n");
 
    hr = D3DPreprocess(data, data_size, filename, defines, include, shader_text, errors);
    if (hresult)
        *hresult = hr;
    return hr;
}