effect.c File Reference

#include "initguid.h"
#include <limits.h>
#include "wine/test.h"
#include "d3dx9.h"

Include dependency graph for effect.c:

Go to the source code of this file.

Classes
struct	test_effect_parameter_value_result
struct	test_state_manager_update
struct	test_manager
struct	d3dxinclude

Macros
#define	COBJMACROS
#define	ADD_PARAMETER_VALUE(x)
#define	EFFECT_PARAMETER_VALUE_ARRAY_SIZE   48
#define	INT_FLOAT_MULTI   255.0f
#define	INT_FLOAT_MULTI_INVERSE   (1/INT_FLOAT_MULTI)
#define	TEST_EFFECT_STATES_VSHADER_POS   315
#define	TEST_EFFECT_PRESHADER_VSHADER_POS   2991
#define	TEST_EFFECT_PRESHADER_VSHADER_LEN   13
#define	test_effect_preshader_compare_shader_bytecode(a, b, c, d)   test_effect_preshader_compare_shader_bytecode_(__LINE__, a, b, c, d)
#define	test_effect_preshader_compare_shader(a, b, c)   test_effect_preshader_compare_shader_(__LINE__, a, b, c)
#define	test_effect_preshader_op_results(a, b, c)   test_effect_preshader_op_results_(__LINE__, a, b, c)
#define	TEST_EFFECT_BITMASK_BLOCK_SIZE   (sizeof(unsigned int) * 8)
#define	test_effect_preshader_compare_vconsts(a, b, c)   test_effect_preshader_compare_vconsts_(__LINE__, a, b, c)
#define	test_effect_preshader_compare_pbool_consts(a, b, c)   test_effect_preshader_compare_pbool_consts_(__LINE__, a, b, c)
#define	test_isparameterused_param_with_children(args...)   test_isparameterused_param_with_children_(__LINE__, args)
#define	INITIAL_UPDATE_RECORD_SIZE   64
#define	test_effect_shared_vs_arr_compare_helper(args...)   test_effect_shared_vs_arr_compare_helper_(__LINE__, args)
#define	test_effect_shared_parameters_compare_vconst(args...)   test_effect_shared_parameters_compare_vconst_(__LINE__, args)
#define	TEST_EFFECT_UNSUPPORTED_SHADER_BYTECODE_VS_3_0_POS   81
#define	TEST_EFFECT_UNSUPPORTED_SHADER_BYTECODE_VS_3_0_LEN   14

Enumerations
enum	expected_state_update { EXPECTED_STATE_ZERO, EXPECTED_STATE_UPDATED, EXPECTED_STATE_ANYTHING }

Functions
static BOOL	compare_float (FLOAT f, FLOAT g, UINT ulps)
static INT	get_int (D3DXPARAMETER_TYPE type, const void *data)
static float	get_float (D3DXPARAMETER_TYPE type, const void *data)
static BOOL	get_bool (const void *data)
static void	set_number (void *outdata, D3DXPARAMETER_TYPE outtype, const void *indata, D3DXPARAMETER_TYPE intype)
static IDirect3DDevice9 *	create_device (HWND *window)
static BOOL	create_file (const char *filename, const char *data, const unsigned int size, char *out_path)
static void	delete_file (const char *filename)
static BOOL	create_directory (const char *name)
static void	delete_directory (const char *name)
static void	test_create_effect_and_pool (IDirect3DDevice9 *device)
static void	test_create_effect_compiler (void)
static void	test_effect_parameter_value_GetValue (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetBool (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetBoolArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetInt (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetIntArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetFloat (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetFloatArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetVector (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetVectorArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetMatrix (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetMatrixArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetMatrixPointerArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetMatrixTranspose (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetMatrixTransposeArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetMatrixTransposePointerArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_GetTestGroup (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value_ResetValue (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
static void	test_effect_parameter_value (IDirect3DDevice9 *device)
static void	test_effect_setvalue_object (IDirect3DDevice9 *device)
static void	test_effect_variable_names (IDirect3DDevice9 *device)
static void	test_effect_compilation_errors (IDirect3DDevice9 *device)
static void	test_effect_clear_vconsts (IDirect3DDevice9 *device)
static void	test_effect_states (IDirect3DDevice9 *device)
static void	test_effect_preshader_compare_shader_bytecode_ (unsigned int line, const DWORD *bytecode, unsigned int bytecode_size, int expected_shader_index, BOOL todo)
static void	test_effect_preshader_compare_shader_ (unsigned int line, IDirect3DDevice9 *device, int expected_shader_index, BOOL todo)
static void	test_effect_preshader_op_results_ (unsigned int line, IDirect3DDevice9 *device, const enum expected_state_update *expected_state, const char *updated_param)
static void	test_effect_preshader_compare_vconsts_ (unsigned int line, IDirect3DDevice9 *device, const unsigned int *const_updated_mask, const char *updated_param)
static void	test_effect_preshader_clear_pbool_consts (IDirect3DDevice9 *device)
static void	test_effect_preshader_compare_pbool_consts_ (unsigned int line, IDirect3DDevice9 *device, const unsigned int *const_updated_mask, const char *updated_param)
static void	test_effect_preshader (IDirect3DDevice9 *device)
static void	test_effect_preshader_ops (IDirect3DDevice9 *device)
static void	test_isparameterused_children (unsigned int line, ID3DXEffect *effect, D3DXHANDLE tech, D3DXHANDLE param)
static void	test_isparameterused_param_with_children_ (unsigned int line, ID3DXEffect *effect, ID3DXEffect *effect2, D3DXHANDLE tech, const char *name, BOOL expected_result)
static void	test_effect_isparameterused (IDirect3DDevice9 *device)
static void	test_effect_out_of_bounds_selector (IDirect3DDevice9 *device)
static void	test_effect_commitchanges (IDirect3DDevice9 *device)
static void	test_effect_preshader_relative_addressing (IDirect3DDevice9 *device)
static struct test_manager *	impl_from_ID3DXEffectStateManager (ID3DXEffectStateManager *iface)
static void	free_test_effect_state_manager (struct test_manager *state_manager)
static ULONG WINAPI	test_manager_AddRef (ID3DXEffectStateManager *iface)
static ULONG WINAPI	test_manager_Release (ID3DXEffectStateManager *iface)
static HRESULT	test_process_set_state (ID3DXEffectStateManager *iface, unsigned int state_op, DWORD param1, DWORD param2)
static HRESULT WINAPI	test_manager_SetTransform (ID3DXEffectStateManager *iface, D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix)
static HRESULT WINAPI	test_manager_SetMaterial (ID3DXEffectStateManager *iface, const D3DMATERIAL9 *material)
static HRESULT WINAPI	test_manager_SetLight (ID3DXEffectStateManager *iface, DWORD index, const D3DLIGHT9 *light)
static HRESULT WINAPI	test_manager_LightEnable (ID3DXEffectStateManager *iface, DWORD index, BOOL enable)
static HRESULT WINAPI	test_manager_SetRenderState (ID3DXEffectStateManager *iface, D3DRENDERSTATETYPE state, DWORD value)
static HRESULT WINAPI	test_manager_SetTexture (ID3DXEffectStateManager *iface, DWORD stage, struct IDirect3DBaseTexture9 *texture)
static HRESULT WINAPI	test_manager_SetTextureStageState (ID3DXEffectStateManager *iface, DWORD stage, D3DTEXTURESTAGESTATETYPE type, DWORD value)
static HRESULT WINAPI	test_manager_SetSamplerState (ID3DXEffectStateManager *iface, DWORD sampler, D3DSAMPLERSTATETYPE type, DWORD value)
static HRESULT WINAPI	test_manager_SetNPatchMode (ID3DXEffectStateManager *iface, FLOAT num_segments)
static HRESULT WINAPI	test_manager_SetFVF (ID3DXEffectStateManager *iface, DWORD format)
static HRESULT WINAPI	test_manager_SetVertexShader (ID3DXEffectStateManager *iface, struct IDirect3DVertexShader9 *shader)
static HRESULT WINAPI	test_manager_SetVertexShaderConstantF (ID3DXEffectStateManager *iface, UINT register_index, const FLOAT *constant_data, UINT register_count)
static HRESULT WINAPI	test_manager_SetVertexShaderConstantI (ID3DXEffectStateManager *iface, UINT register_index, const INT *constant_data, UINT register_count)
static HRESULT WINAPI	test_manager_SetVertexShaderConstantB (ID3DXEffectStateManager *iface, UINT register_index, const BOOL *constant_data, UINT register_count)
static HRESULT WINAPI	test_manager_SetPixelShader (ID3DXEffectStateManager *iface, struct IDirect3DPixelShader9 *shader)
static HRESULT WINAPI	test_manager_SetPixelShaderConstantF (ID3DXEffectStateManager *iface, UINT register_index, const FLOAT *constant_data, UINT register_count)
static HRESULT WINAPI	test_manager_SetPixelShaderConstantI (ID3DXEffectStateManager *iface, UINT register_index, const INT *constant_data, UINT register_count)
static HRESULT WINAPI	test_manager_SetPixelShaderConstantB (ID3DXEffectStateManager *iface, UINT register_index, const BOOL *constant_data, UINT register_count)
static void	test_effect_state_manager_init (struct test_manager *state_manager, IDirect3DDevice9 *device)
static int	compare_update_record (const void *a, const void *b)
static void	test_effect_state_manager (IDirect3DDevice9 *device)
static void	test_cross_effect_handle (IDirect3DDevice9 *device)
static void	test_effect_shared_vs_arr_compare_helper_ (unsigned int line, ID3DXEffect *effect, D3DXHANDLE param_child, struct IDirect3DVertexShader9 *vshader1, unsigned int element, BOOL todo)
static void	test_effect_shared_parameters_compare_vconst_ (unsigned int line, IDirect3DDevice9 *device, unsigned int index, const D3DXVECTOR4 *expected_fvect, BOOL todo)
static void	test_effect_shared_parameters (IDirect3DDevice9 *device)
static void	test_effect_large_address_aware_flag (IDirect3DDevice9 *device)
static void	test_effect_get_pass_desc (IDirect3DDevice9 *device)
static void	test_effect_skip_constants (IDirect3DDevice9 *device)
static void	test_effect_unsupported_shader (void)
static void	test_effect_null_shader (void)
static void	test_effect_clone (void)
static unsigned int	get_texture_refcount (IDirect3DTexture9 *iface)
static void	test_refcount (void)
static HRESULT WINAPI	d3dxinclude_open (ID3DXInclude *iface, D3DXINCLUDE_TYPE include_type, const char *filename, const void *parent_data, const void **data, UINT *bytes)
static HRESULT WINAPI	d3dxinclude_close (ID3DXInclude *iface, const void *data)
static void	test_create_effect_from_file (void)
static void	test_effect_find_next_valid_technique (void)
static void	test_effect_parameter_block (void)
	START_TEST (effect)

Variables
static char	temp_path [MAX_PATH]
static const char	effect_desc []
static const DWORD	test_effect_parameter_value_blob_float []
struct test_effect_parameter_value_result	test_effect_parameter_value_result_float []
static const DWORD	test_effect_parameter_value_blob_int []
struct test_effect_parameter_value_result	test_effect_parameter_value_result_int []
static const DWORD	test_effect_parameter_value_blob_object []
struct test_effect_parameter_value_result	test_effect_parameter_value_result_object []
static const DWORD	test_effect_parameter_value_blob_special []
struct test_effect_parameter_value_result	test_effect_parameter_value_result_special []
struct {
const DWORD *   blob
UINT   blob_size
const struct test_effect_parameter_value_result *   res
UINT   res_count
}	test_effect_parameter_value_data []
static const DWORD	test_effect_variable_names_blob []
static const DWORD	test_effect_states_effect_blob []
static const D3DXVECTOR4	fvect_filler = {-9999.0f, -9999.0f, -9999.0f, -9999.0f}
static const DWORD	test_effect_preshader_effect_blob []
struct {
const char *   comment
BOOL   todo [4]
unsigned int   result [4]
unsigned int   ulps
}	test_effect_preshader_op_expected []
static const D3DXVECTOR4	test_effect_preshader_fvect_v []
static const BOOL	test_effect_preshader_bconsts []
static const DWORD	test_effect_preshader_ops_blob []
static const char *	test_effect_state_manager_state_names []
static const DWORD	test_effect_shared_parameters_blob []
static const DWORD	test_effect_skip_constants_blob []
static const DWORD	test_effect_unsupported_shader_blob []
static const DWORD	test_effect_null_shader_blob []
static const struct ID3DXIncludeVtbl	d3dxinclude_vtbl
static const DWORD	test_two_techniques_blob []

Macro Definition Documentation

ADD_PARAMETER_VALUE

#define ADD_PARAMETER_VALUE

(

x

)

Value:

{\
    test_effect_parameter_value_blob_ ## x,\
    sizeof(test_effect_parameter_value_blob_ ## x),\
    test_effect_parameter_value_result_ ## x,\
    ARRAY_SIZE(test_effect_parameter_value_result_ ## x),\
}

Definition at line 971 of file effect.c.

COBJMACROS

#define COBJMACROS

Definition at line 19 of file effect.c.

EFFECT_PARAMETER_VALUE_ARRAY_SIZE

#define EFFECT_PARAMETER_VALUE_ARRAY_SIZE   48

Definition at line 996 of file effect.c.

INITIAL_UPDATE_RECORD_SIZE

#define INITIAL_UPDATE_RECORD_SIZE   64

Definition at line 6063 of file effect.c.

INT_FLOAT_MULTI

#define INT_FLOAT_MULTI   255.0f

Definition at line 998 of file effect.c.

INT_FLOAT_MULTI_INVERSE

#define INT_FLOAT_MULTI_INVERSE   (1/INT_FLOAT_MULTI)

Definition at line 999 of file effect.c.

TEST_EFFECT_BITMASK_BLOCK_SIZE

#define TEST_EFFECT_BITMASK_BLOCK_SIZE   (sizeof(unsigned int) * 8)

Definition at line 4447 of file effect.c.

test_effect_preshader_compare_pbool_consts

#define test_effect_preshader_compare_pbool_consts	(		a,
			b,
			c
	)		test_effect_preshader_compare_pbool_consts_(__LINE__, a, b, c)

Definition at line 4517 of file effect.c.

test_effect_preshader_compare_shader

#define test_effect_preshader_compare_shader	(		a,
			b,
			c
	)		test_effect_preshader_compare_shader_(__LINE__, a, b, c)

Definition at line 4294 of file effect.c.

test_effect_preshader_compare_shader_bytecode

#define test_effect_preshader_compare_shader_bytecode	(		a,
			b,
			c,
			d
	)		test_effect_preshader_compare_shader_bytecode_(__LINE__, a, b, c, d)

Definition at line 4267 of file effect.c.

test_effect_preshader_compare_vconsts

#define test_effect_preshader_compare_vconsts	(		a,
			b,
			c
	)		test_effect_preshader_compare_vconsts_(__LINE__, a, b, c)

Definition at line 4449 of file effect.c.

test_effect_preshader_op_results

#define test_effect_preshader_op_results	(		a,
			b,
			c
	)		test_effect_preshader_op_results_(__LINE__, a, b, c)

Definition at line 4371 of file effect.c.

TEST_EFFECT_PRESHADER_VSHADER_LEN

#define TEST_EFFECT_PRESHADER_VSHADER_LEN   13

Definition at line 4265 of file effect.c.

TEST_EFFECT_PRESHADER_VSHADER_POS

#define TEST_EFFECT_PRESHADER_VSHADER_POS   2991

Definition at line 4264 of file effect.c.

test_effect_shared_parameters_compare_vconst

#define test_effect_shared_parameters_compare_vconst

(

args...

)

test_effect_shared_parameters_compare_vconst_(__LINE__, args)

Definition at line 6587 of file effect.c.

test_effect_shared_vs_arr_compare_helper

#define test_effect_shared_vs_arr_compare_helper

(

args...

)

test_effect_shared_vs_arr_compare_helper_(__LINE__, args)

Definition at line 6561 of file effect.c.

TEST_EFFECT_STATES_VSHADER_POS

#define TEST_EFFECT_STATES_VSHADER_POS   315

Definition at line 2992 of file effect.c.

TEST_EFFECT_UNSUPPORTED_SHADER_BYTECODE_VS_3_0_LEN

#define TEST_EFFECT_UNSUPPORTED_SHADER_BYTECODE_VS_3_0_LEN   14

Definition at line 7198 of file effect.c.

TEST_EFFECT_UNSUPPORTED_SHADER_BYTECODE_VS_3_0_POS

#define TEST_EFFECT_UNSUPPORTED_SHADER_BYTECODE_VS_3_0_POS   81

Definition at line 7197 of file effect.c.

test_isparameterused_param_with_children

#define test_isparameterused_param_with_children

(

args...

)

test_isparameterused_param_with_children_(__LINE__, args)

Definition at line 5132 of file effect.c.

Enumeration Type Documentation

expected_state_update

enum expected_state_update

Enumerator
EXPECTED_STATE_ZERO
EXPECTED_STATE_UPDATED
EXPECTED_STATE_ANYTHING

Definition at line 4364 of file effect.c.

{
    EXPECTED_STATE_ZERO,
    EXPECTED_STATE_UPDATED,
    EXPECTED_STATE_ANYTHING
};

Function Documentation

compare_float()

static BOOL compare_float ( FLOAT  f, FLOAT  g, UINT  ulps  )

static

Definition at line 26 of file effect.c.

{
    INT x = *(INT *)&f;
    INT y = *(INT *)&g;

    if (x < 0)
        x = INT_MIN - x;
    if (y < 0)
        y = INT_MIN - y;

    if (abs(x - y) > ulps)
        return FALSE;

    return TRUE;
}

Referenced by test_effect_parameter_value_GetFloat(), test_effect_parameter_value_GetFloatArray(), test_effect_parameter_value_GetMatrix(), test_effect_parameter_value_GetMatrixArray(), test_effect_parameter_value_GetMatrixPointerArray(), test_effect_parameter_value_GetMatrixTranspose(), test_effect_parameter_value_GetMatrixTransposeArray(), test_effect_parameter_value_GetMatrixTransposePointerArray(), test_effect_parameter_value_GetVector(), test_effect_parameter_value_GetVectorArray(), test_effect_preshader_op_results_(), test_effect_preshader_ops(), and test_effect_preshader_relative_addressing().

compare_update_record()

static int compare_update_record ( const void *  a, const void *  b  )

static

Definition at line 6298 of file effect.c.

{
    const struct test_state_manager_update *r1 = (const struct test_state_manager_update *)a;
    const struct test_state_manager_update *r2 = (const struct test_state_manager_update *)b;

    if (r1->state_op != r2->state_op)
        return r1->state_op - r2->state_op;
    if (r1->param1 != r2->param1)
        return r1->param1 - r2->param1;
    return r1->param2 - r2->param2;
}

Referenced by test_effect_state_manager().

create_device()

static IDirect3DDevice9* create_device ( HWND *  window )

static

Definition at line 131 of file effect.c.

{
    D3DPRESENT_PARAMETERS present_parameters = { 0 };
    IDirect3DDevice9 *device;
    IDirect3D9 *d3d;
    HRESULT hr;
    HWND wnd;

    *window = NULL;

    if (!(wnd = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
            640, 480, NULL, NULL, NULL, NULL)))
    {
        skip("Couldn't create application window.\n");
        return NULL;
    }

    if (!(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
    {
        skip("Couldn't create IDirect3D9 object.\n");
        DestroyWindow(wnd);
        return NULL;
    }

    present_parameters.Windowed = TRUE;
    present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
    hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, wnd, D3DCREATE_HARDWARE_VERTEXPROCESSING,
            &present_parameters, &device);
    IDirect3D9_Release(d3d);
    if (FAILED(hr))
    {
        skip("Failed to create IDirect3DDevice9 object %#x.\n", hr);
        DestroyWindow(wnd);
        return NULL;
    }

    *window = wnd;
    return device;
}

Referenced by START_TEST(), test_effect_clone(), test_effect_null_shader(), test_effect_unsupported_shader(), and test_refcount().

create_directory()

static BOOL create_directory ( const char *  name )

static

Definition at line 210 of file effect.c.

{
    char path[MAX_PATH];

    strcpy(path, temp_path);
    strcat(path, name);
    return CreateDirectoryA(path, NULL);
}

Referenced by test_create_effect_from_file().

create_file()

static BOOL create_file ( const char *  filename, const char *  data, const unsigned int  size, char *  out_path  )

static

Definition at line 173 of file effect.c.

{
    DWORD written;
    HANDLE hfile;
    char path[MAX_PATH];

    if (!*temp_path)
        GetTempPathA(sizeof(temp_path), temp_path);

    strcpy(path, temp_path);
    strcat(path, filename);
    hfile = CreateFileA(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
    if (hfile == INVALID_HANDLE_VALUE)
        return FALSE;

    if (WriteFile(hfile, data, size, &written, NULL))
    {
        CloseHandle(hfile);

        if (out_path)
            strcpy(out_path, path);
        return TRUE;
    }

    CloseHandle(hfile);
    return FALSE;
}

Referenced by test_create_effect_from_file().

d3dxinclude_close()

static HRESULT WINAPI d3dxinclude_close ( ID3DXInclude *  iface, const void *  data  )

static

Definition at line 7657 of file effect.c.

{
    HeapFree(GetProcessHeap(), 0, (void *)data);
    return S_OK;
}

d3dxinclude_open()

static HRESULT WINAPI d3dxinclude_open ( ID3DXInclude *  iface, D3DXINCLUDE_TYPE  include_type, const char *  filename, const void *  parent_data, const void **  data, UINT *  bytes  )

static

Definition at line 7579 of file effect.c.

{
    static const char include1[] =
        "float4 light;\n"
        "float4x4 mat;\n"
        "float4 color;\n"
        "\n"
        "struct vs_input\n"
        "{\n"
        "    float4 position : POSITION;\n"
        "    float3 normal : NORMAL;\n"
        "};\n"
        "\n"
        "struct vs_output\n"
        "{\n"
        "    float4 position : POSITION;\n"
        "    float4 diffuse : COLOR;\n"
        "};\n";
    static const char include2[] =
        "#include \"include1.h\"\n"
        "\n"
        "vs_output vs_main(const vs_input v)\n"
        "{\n"
        "    vs_output o;\n"
        "    const float4 scaled_color = 0.5 * color;\n"
        "\n"
        "    o.position = mul(v.position, mat);\n"
        "    o.diffuse = dot((float3)light, v.normal) * scaled_color;\n"
        "\n"
        "    return o;\n"
        "}\n";
    static const char effect2[] =
        "#include \"include\\include2.h\"\n"
        "\n"
        "technique t\n"
        "{\n"
        "    pass p\n"
        "    {\n"
        "        VertexShader = compile vs_2_0 vs_main();\n"
        "    }\n"
        "}\n";
    char *buffer;

    trace("filename %s.\n", filename);
    trace("parent_data %p: %s.\n", parent_data, parent_data ? (char *)parent_data : "(null)");

    if (!strcmp(filename, "effect2.fx"))
    {
        buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(effect2));
        memcpy(buffer, effect2, sizeof(effect2));
        *bytes = sizeof(effect2);
        ok(!parent_data, "Unexpected parent_data value.\n");
    }
    else if (!strcmp(filename, "include1.h"))
    {
        buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(include1));
        memcpy(buffer, include1, sizeof(include1));
        *bytes = sizeof(include1);
        ok(!strncmp(parent_data, include2, strlen(include2)), "Unexpected parent_data value.\n");
    }
    else if (!strcmp(filename, "include\\include2.h"))
    {
        buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(include2));
        memcpy(buffer, include2, sizeof(include2));
        *bytes = sizeof(include2);
        todo_wine ok(parent_data && !strncmp(parent_data, effect2, strlen(effect2)),
                "unexpected parent_data value.\n");
    }
    else
    {
        ok(0, "Unexpected #include for file %s.\n", filename);
        return D3DERR_INVALIDCALL;
    }
    *data = buffer;
    return S_OK;
}

delete_directory()

static void delete_directory ( const char *  name )

static

Definition at line 219 of file effect.c.

{
    char path[MAX_PATH];

    strcpy(path, temp_path);
    strcat(path, name);
    RemoveDirectoryA(path);
}

Referenced by test_create_effect_from_file().

delete_file()

static void delete_file ( const char *  filename )

static

Definition at line 201 of file effect.c.

{
    char path[MAX_PATH];

    strcpy(path, temp_path);
    strcat(path, filename);
    DeleteFileA(path);
}

Referenced by test_create_effect_from_file().

free_test_effect_state_manager()

static void free_test_effect_state_manager ( struct test_manager *  state_manager )

static

Definition at line 6070 of file effect.c.

{
    HeapFree(GetProcessHeap(), 0, state_manager->update_record);
    state_manager->update_record = NULL;

    IDirect3DDevice9_Release(state_manager->device);
}

Referenced by test_manager_Release().

get_bool()

static BOOL get_bool ( const void *  data )

inlinestatic

Definition at line 96 of file effect.c.

{
    return !!*(BOOL *)data;
}

Referenced by set_number(), test_effect_parameter_value_GetBool(), and test_effect_parameter_value_GetBoolArray().

get_float()

static float get_float ( D3DXPARAMETER_TYPE  type, const void *  data  )

inlinestatic

Definition at line 69 of file effect.c.

{
    float f;

    switch (type)
    {
        case D3DXPT_FLOAT:
            f = *(FLOAT *)data;
            break;

        case D3DXPT_INT:
            f = *(INT *)data;
            break;

        case D3DXPT_BOOL:
            f = *(BOOL *)data;
            break;

        default:
            f = 0.0f;
            ok(0, "Unhandled type %x.\n", type);
            break;
    }

    return f;
}

Referenced by set_number(), test_effect_parameter_value_GetFloat(), test_effect_parameter_value_GetFloatArray(), test_effect_parameter_value_GetMatrix(), test_effect_parameter_value_GetMatrixArray(), test_effect_parameter_value_GetMatrixPointerArray(), test_effect_parameter_value_GetMatrixTranspose(), test_effect_parameter_value_GetMatrixTransposeArray(), test_effect_parameter_value_GetMatrixTransposePointerArray(), test_effect_parameter_value_GetVector(), and test_effect_parameter_value_GetVectorArray().

get_int()

static INT get_int ( D3DXPARAMETER_TYPE  type, const void *  data  )

inlinestatic

Definition at line 42 of file effect.c.

{
    INT i;

    switch (type)
    {
        case D3DXPT_FLOAT:
            i = *(FLOAT *)data;
            break;

        case D3DXPT_INT:
            i = *(INT *)data;
            break;

        case D3DXPT_BOOL:
            i = *(BOOL *)data;
            break;

        default:
            i = 0;
            ok(0, "Unhandled type %x.\n", type);
            break;
    }

    return i;
}

Referenced by set_number(), test_effect_parameter_value_GetInt(), and test_effect_parameter_value_GetIntArray().

get_texture_refcount()

static unsigned int get_texture_refcount ( IDirect3DTexture9 *  iface )

static

Definition at line 7462 of file effect.c.

{
    IDirect3DTexture9_AddRef(iface);
    return IDirect3DTexture9_Release(iface);
}

Referenced by test_refcount().

impl_from_ID3DXEffectStateManager()

static struct test_manager* impl_from_ID3DXEffectStateManager ( ID3DXEffectStateManager *  iface )

static

Definition at line 6065 of file effect.c.

{
    return CONTAINING_RECORD(iface, struct test_manager, ID3DXEffectStateManager_iface);
}

Referenced by test_manager_AddRef(), test_manager_LightEnable(), test_manager_Release(), test_manager_SetLight(), and test_process_set_state().

set_number()

static void set_number ( void *  outdata, D3DXPARAMETER_TYPE  outtype, const void *  indata, D3DXPARAMETER_TYPE  intype  )

static

Definition at line 101 of file effect.c.

{
    switch (outtype)
    {
        case D3DXPT_FLOAT:
            *(FLOAT *)outdata = get_float(intype, indata);
            break;

        case D3DXPT_BOOL:
            *(BOOL *)outdata = get_bool(indata);
            break;

        case D3DXPT_INT:
            *(INT *)outdata = get_int(intype, indata);
            break;

        case D3DXPT_PIXELSHADER:
        case D3DXPT_VERTEXSHADER:
        case D3DXPT_TEXTURE2D:
        case D3DXPT_STRING:
            *(INT *)outdata = 0x12345678;
            break;

        default:
            ok(0, "Unhandled type %x.\n", outtype);
            *(INT *)outdata = 0;
            break;
    }
}

Referenced by d3dx_effect_GetBool(), d3dx_effect_GetBoolArray(), d3dx_effect_GetFloat(), d3dx_effect_GetFloatArray(), d3dx_effect_GetInt(), d3dx_effect_GetIntArray(), d3dx_effect_SetBool(), d3dx_effect_SetBoolArray(), d3dx_effect_SetFloat(), d3dx_effect_SetFloatArray(), d3dx_effect_SetInt(), d3dx_effect_SetIntArray(), get_matrix(), get_vector(), set_matrix(), set_matrix_transpose(), set_vector(), and test_effect_parameter_value().

START_TEST()

START_TEST

(

effect

)

Definition at line 8359 of file effect.c.

{
    IDirect3DDevice9 *device;
    ULONG refcount;
    HWND wnd;

    if (!(device = create_device(&wnd)))
        return;

    test_create_effect_and_pool(device);
    test_create_effect_compiler();
    test_effect_parameter_value(device);
    test_effect_setvalue_object(device);
    test_effect_variable_names(device);
    test_effect_compilation_errors(device);
    test_effect_states(device);
    test_effect_preshader(device);
    test_effect_preshader_ops(device);
    test_effect_isparameterused(device);
    test_effect_out_of_bounds_selector(device);
    test_effect_commitchanges(device);
    test_effect_preshader_relative_addressing(device);
    test_effect_state_manager(device);
    test_cross_effect_handle(device);
    test_effect_shared_parameters(device);
    test_effect_large_address_aware_flag(device);
    test_effect_get_pass_desc(device);
    test_effect_skip_constants(device);

    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %u references left.\n", refcount);
    DestroyWindow(wnd);

    test_effect_unsupported_shader();
    test_effect_null_shader();
    test_effect_clone();
    test_refcount();
    test_create_effect_from_file();
    test_effect_find_next_valid_technique();
    test_effect_parameter_block();
}

test_create_effect_and_pool()

static void test_create_effect_and_pool ( IDirect3DDevice9 *  device )

static

Definition at line 233 of file effect.c.

{
    HRESULT hr;
    ID3DXEffect *effect;
    ID3DXBaseEffect *base;
    ULONG count;
    IDirect3DDevice9 *device2;
    ID3DXEffectStateManager *manager = (ID3DXEffectStateManager *)0xdeadbeef;
    ID3DXEffectPool *pool = (ID3DXEffectPool *)0xdeadbeef, *pool2;

    hr = D3DXCreateEffect(NULL, effect_desc, sizeof(effect_desc), NULL, NULL, 0, NULL, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    hr = D3DXCreateEffect(device, NULL, 0, NULL, NULL, 0, NULL, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    hr = D3DXCreateEffect(device, effect_desc, 0, NULL, NULL, 0, NULL, NULL, NULL);
    ok(hr == E_FAIL, "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, E_FAIL);

    hr = D3DXCreateEffect(device, effect_desc, sizeof(effect_desc), NULL, NULL, 0, NULL, NULL, NULL);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);

    hr = D3DXCreateEffect(device, effect_desc, sizeof(effect_desc), NULL, NULL, 0, NULL, &effect, NULL);
    todo_wine ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
    if (FAILED(hr))
    {
        skip("Failed to compile effect, skipping test.\n");
        return;
    }

    hr = effect->lpVtbl->QueryInterface(effect, &IID_ID3DXBaseEffect, (void **)&base);
    ok(hr == E_NOINTERFACE, "QueryInterface failed, got %x, expected %x (E_NOINTERFACE)\n", hr, E_NOINTERFACE);

    hr = effect->lpVtbl->GetStateManager(effect, NULL);
    ok(hr == D3DERR_INVALIDCALL, "GetStateManager failed, got %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    hr = effect->lpVtbl->GetStateManager(effect, &manager);
    ok(hr == D3D_OK, "GetStateManager failed, got %x, expected 0 (D3D_OK)\n", hr);
    ok(!manager, "GetStateManager failed, got %p\n", manager);

    /* this works, but it is not recommended! */
    hr = effect->lpVtbl->SetStateManager(effect, (ID3DXEffectStateManager *)device);
    ok(hr == D3D_OK, "SetStateManager failed, got %x, expected 0 (D3D_OK)\n", hr);

    hr = effect->lpVtbl->GetStateManager(effect, &manager);
    ok(hr == D3D_OK, "GetStateManager failed, got %x, expected 0 (D3D_OK)\n", hr);
    ok(manager != NULL, "GetStateManager failed\n");

    IDirect3DDevice9_AddRef(device);
    count = IDirect3DDevice9_Release(device);
    ok(count == 4, "Release failed, got %u, expected 4\n", count);

    count = IUnknown_Release(manager);
    ok(count == 3, "Release failed, got %u, expected 3\n", count);

    hr = effect->lpVtbl->SetStateManager(effect, NULL);
    ok(hr == D3D_OK, "SetStateManager failed, got %x, expected 0 (D3D_OK)\n", hr);

    hr = effect->lpVtbl->GetPool(effect, &pool);
    ok(hr == D3D_OK, "GetPool failed, got %x, expected 0 (D3D_OK)\n", hr);
    ok(!pool, "GetPool failed, got %p\n", pool);

    hr = effect->lpVtbl->GetPool(effect, NULL);
    ok(hr == D3DERR_INVALIDCALL, "GetPool failed, got %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    hr = effect->lpVtbl->GetDevice(effect, &device2);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);

    hr = effect->lpVtbl->GetDevice(effect, NULL);
    ok(hr == D3DERR_INVALIDCALL, "GetDevice failed, got %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    count = IDirect3DDevice9_Release(device2);
    ok(count == 2, "Release failed, got %u, expected 2\n", count);

    count = effect->lpVtbl->Release(effect);
    ok(count == 0, "Release failed %u\n", count);

    hr = D3DXCreateEffectPool(NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    hr = D3DXCreateEffectPool(&pool);
    ok(hr == S_OK, "Got result %x, expected 0 (S_OK)\n", hr);

    count = pool->lpVtbl->Release(pool);
    ok(count == 0, "Release failed %u\n", count);

    hr = D3DXCreateEffectPool(&pool);
    ok(hr == S_OK, "Got result %x, expected 0 (S_OK)\n", hr);

    hr = D3DXCreateEffect(device, effect_desc, sizeof(effect_desc), NULL, NULL, 0, pool, NULL, NULL);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);

    hr = pool->lpVtbl->QueryInterface(pool, &IID_ID3DXEffectPool, (void **)&pool2);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
    ok(pool == pool2, "Got effect pool %p, expected %p.\n", pool2, pool);

    count = pool2->lpVtbl->Release(pool2);
    ok(count == 1, "Release failed, got %u, expected 1\n", count);

    hr = IDirect3DDevice9_QueryInterface(device, &IID_IDirect3DDevice9, (void **)&device2);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);

    count = IDirect3DDevice9_Release(device2);
    ok(count == 1, "Release failed, got %u, expected 1\n", count);

    hr = D3DXCreateEffect(device, effect_desc, sizeof(effect_desc), NULL, NULL, 0, pool, &effect, NULL);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);

    hr = effect->lpVtbl->GetPool(effect, &pool);
    ok(hr == D3D_OK, "GetPool failed, got %x, expected 0 (D3D_OK)\n", hr);
    ok(pool == pool2, "Got effect pool %p, expected %p.\n", pool2, pool);

    count = pool2->lpVtbl->Release(pool2);
    ok(count == 2, "Release failed, got %u, expected 2\n", count);

    count = effect->lpVtbl->Release(effect);
    ok(count == 0, "Release failed %u\n", count);

    count = pool->lpVtbl->Release(pool);
    ok(count == 0, "Release failed %u\n", count);
}

Referenced by START_TEST().

test_create_effect_compiler()

static void test_create_effect_compiler ( void  )

static

Definition at line 355 of file effect.c.

{
    HRESULT hr;
    ID3DXEffectCompiler *compiler, *compiler2;
    ID3DXBaseEffect *base;
    IUnknown *unknown;
    ULONG count;

    hr = D3DXCreateEffectCompiler(NULL, 0, NULL, NULL, 0, &compiler, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    hr = D3DXCreateEffectCompiler(NULL, 0, NULL, NULL, 0, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    hr = D3DXCreateEffectCompiler(effect_desc, 0, NULL, NULL, 0, &compiler, NULL);
    ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);
    if (FAILED(hr))
    {
        skip("D3DXCreateEffectCompiler failed, skipping test.\n");
        return;
    }

    count = compiler->lpVtbl->Release(compiler);
    ok(count == 0, "Release failed %u\n", count);

    hr = D3DXCreateEffectCompiler(effect_desc, 0, NULL, NULL, 0, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    hr = D3DXCreateEffectCompiler(NULL, sizeof(effect_desc), NULL, NULL, 0, &compiler, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    hr = D3DXCreateEffectCompiler(NULL, sizeof(effect_desc), NULL, NULL, 0, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    hr = D3DXCreateEffectCompiler(effect_desc, sizeof(effect_desc), NULL, NULL, 0, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);

    hr = D3DXCreateEffectCompiler(effect_desc, sizeof(effect_desc), NULL, NULL, 0, &compiler, NULL);
    ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);

    hr = compiler->lpVtbl->QueryInterface(compiler, &IID_ID3DXBaseEffect, (void **)&base);
    ok(hr == E_NOINTERFACE, "QueryInterface failed, got %x, expected %x (E_NOINTERFACE)\n", hr, E_NOINTERFACE);

    hr = compiler->lpVtbl->QueryInterface(compiler, &IID_ID3DXEffectCompiler, (void **)&compiler2);
    ok(hr == D3D_OK, "QueryInterface failed, got %x, expected %x (D3D_OK)\n", hr, D3D_OK);

    hr = compiler->lpVtbl->QueryInterface(compiler, &IID_IUnknown, (void **)&unknown);
    ok(hr == D3D_OK, "QueryInterface failed, got %x, expected %x (D3D_OK)\n", hr, D3D_OK);

    count = unknown->lpVtbl->Release(unknown);
    ok(count == 2, "Release failed, got %u, expected %u\n", count, 2);

    count = compiler2->lpVtbl->Release(compiler2);
    ok(count == 1, "Release failed, got %u, expected %u\n", count, 1);

    count = compiler->lpVtbl->Release(compiler);
    ok(count == 0, "Release failed %u\n", count);
}

Referenced by START_TEST().

test_create_effect_from_file()

static void test_create_effect_from_file ( void  )

static

Definition at line 7674 of file effect.c.

{
    static const char effect1[] =
        "float4 light;\n"
        "float4x4 mat;\n"
        "float4 color;\n"
        "\n"
        "struct vs_input\n"
        "{\n"
        "    float4 position : POSITION;\n"
        "    float3 normal : NORMAL;\n"
        "};\n"
        "\n"
        "struct vs_output\n"
        "{\n"
        "    float4 position : POSITION;\n"
        "    float4 diffuse : COLOR;\n"
        "};\n"
        "\n"
        "vs_output vs_main(const vs_input v)\n"
        "{\n"
        "    vs_output o;\n"
        "    const float4 scaled_color = 0.5 * color;\n"
        "\n"
        "    o.position = mul(v.position, mat);\n"
        "    o.diffuse = dot((float3)light, v.normal) * scaled_color;\n"
        "\n"
        "    return o;\n"
        "}\n"
        "\n"
        "technique t\n"
        "{\n"
        "    pass p\n"
        "    {\n"
        "        VertexShader = compile vs_2_0 vs_main();\n"
        "    }\n"
        "}\n";
    static const char include1[] =
        "float4 light;\n"
        "float4x4 mat;\n"
        "float4 color;\n"
        "\n"
        "struct vs_input\n"
        "{\n"
        "    float4 position : POSITION;\n"
        "    float3 normal : NORMAL;\n"
        "};\n"
        "\n"
        "struct vs_output\n"
        "{\n"
        "    float4 position : POSITION;\n"
        "    float4 diffuse : COLOR;\n"
        "};\n";
    static const char include1_wrong[] =
        "#error \"wrong include\"\n";
    static const char include2[] =
        "#include \"include1.h\"\n"
        "\n"
        "vs_output vs_main(const vs_input v)\n"
        "{\n"
        "    vs_output o;\n"
        "    const float4 scaled_color = 0.5 * color;\n"
        "\n"
        "    o.position = mul(v.position, mat);\n"
        "    o.diffuse = dot((float3)light, v.normal) * scaled_color;\n"
        "\n"
        "    return o;\n"
        "}\n";
    static const char effect2[] =
        "#include \"include\\include2.h\"\n"
        "\n"
        "technique t\n"
        "{\n"
        "    pass p\n"
        "    {\n"
        "        VertexShader = compile vs_2_0 vs_main();\n"
        "    }\n"
        "}\n";
    WCHAR effect_path_w[MAX_PATH], filename_w[MAX_PATH];
    char effect_path[MAX_PATH], filename[MAX_PATH];
    D3DPRESENT_PARAMETERS present_parameters = {0};
    unsigned int filename_size;
    struct d3dxinclude include;
    IDirect3DDevice9 *device;
    ID3DXBuffer *messages;
    ID3DXEffect *effect;
    IDirect3D9 *d3d;
    ULONG refcount;
    HWND window;
    HRESULT hr;

    if (!(window = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
            640, 480, NULL, NULL, NULL, NULL)))
    {
        skip("Failed to create window.\n");
        return;
    }
    if (!(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
    {
        skip("Failed to create IDirect3D9 object.\n");
        DestroyWindow(window);
        return;
    }
    present_parameters.Windowed = TRUE;
    present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
    hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
            D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device);
    if (FAILED(hr))
    {
        skip("Failed to create IDirect3DDevice9 object, hr %#x.\n", hr);
        IDirect3D9_Release(d3d);
        DestroyWindow(window);
        return;
    }

    if (!create_file("effect1.fx", effect1, sizeof(effect1) - 1, filename))
    {
        skip("Couldn't create temporary file, skipping test.\n");
        return;
    }

    filename_size = strlen(filename);
    filename_size -= sizeof("effect1.fx") - 1;
    memcpy(effect_path, filename, filename_size);
    effect_path[filename_size] = 0;
    MultiByteToWideChar(CP_ACP, 0, effect_path, -1, effect_path_w, ARRAY_SIZE(effect_path_w));

    create_directory("include");
    create_file("effect2.fx", effect2, sizeof(effect2) - 1, NULL);
    create_file("include\\include1.h", include1, sizeof(include1) - 1, NULL);
    create_file("include\\include2.h", include2, sizeof(include2) - 1, NULL);
    create_file("include1.h", include1_wrong, sizeof(include1_wrong) - 1, NULL);

    lstrcpyW(filename_w, effect_path_w);
    lstrcatW(filename_w, L"effect1.fx");
    effect = NULL;
    messages = NULL;
    hr = D3DXCreateEffectFromFileExW(device, filename_w, NULL, NULL, NULL,
            0, NULL, &effect, &messages);
    todo_wine ok(hr == D3D_OK, "Unexpected hr %#x.\n", hr);
    if (messages)
    {
        trace("D3DXCreateEffectFromFileExW messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
        ID3DXBuffer_Release(messages);
    }
    if (effect)
        effect->lpVtbl->Release(effect);

    lstrcpyW(filename_w, effect_path_w);
    lstrcatW(filename_w, L"effect2.fx");
    effect = NULL;
    messages = NULL;
    /* This is apparently broken on native, it ends up using the wrong include. */
    hr = D3DXCreateEffectFromFileExW(device, filename_w, NULL, NULL, NULL,
            0, NULL, &effect, &messages);
    todo_wine ok(hr == E_FAIL, "Unexpected error, hr %#x.\n", hr);
    if (messages)
    {
        trace("D3DXCreateEffectFromFileExW messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
        ID3DXBuffer_Release(messages);
    }
    if (effect)
        effect->lpVtbl->Release(effect);

    delete_file("effect1.fx");
    delete_file("effect2.fx");
    delete_file("include\\include1.h");
    delete_file("include\\include2.h");
    delete_file("include2.h");
    delete_directory("include");

    lstrcpyW(filename_w, L"effect2.fx");
    effect = NULL;
    messages = NULL;
    include.ID3DXInclude_iface.lpVtbl = &d3dxinclude_vtbl;
    /* This is actually broken in native d3dx9 (manually tried multiple
     * versions, all are affected). For reference, the message printed below
     * is "ID3DXEffectCompiler: There were no techniques" */
    hr = D3DXCreateEffectFromFileExW(device, filename_w, NULL, &include.ID3DXInclude_iface, NULL,
            0, NULL, &effect, &messages);
    todo_wine ok(hr == E_FAIL, "D3DXInclude test failed with error %#x.\n", hr);
    if (messages)
    {
        trace("D3DXCreateEffectFromFileExW messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
        ID3DXBuffer_Release(messages);
    }

    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %u references left.\n", refcount);
    IDirect3D9_Release(d3d);
    DestroyWindow(window);
}

Referenced by START_TEST().

test_cross_effect_handle()

static void test_cross_effect_handle ( IDirect3DDevice9 *  device )

static

Definition at line 6423 of file effect.c.

{
    ID3DXEffect *effect1, *effect2;
    D3DXHANDLE param1, param2;
    static int expected_ivect[4] = {28, 29, 30, 31};
    int ivect[4];
    HRESULT hr;

    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, 0, NULL, &effect1, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, 0, NULL, &effect2, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    ok(effect1 != effect2, "Got same effect unexpectedly.\n");

    param1 = effect1->lpVtbl->GetParameterByName(effect1, NULL, "g_iVect");
    ok(!!param1, "GetParameterByName failed.\n");

    param2 = effect2->lpVtbl->GetParameterByName(effect2, NULL, "g_iVect");
    ok(!!param2, "GetParameterByName failed.\n");

    ok(param1 != param2, "Got same parameter handle unexpectedly.\n");

    hr = effect2->lpVtbl->SetValue(effect2, param1, expected_ivect, sizeof(expected_ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect1->lpVtbl->GetValue(effect1, param1, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    ok(!memcmp(ivect, expected_ivect, sizeof(expected_ivect)), "Vector value mismatch.\n");

    effect2->lpVtbl->Release(effect2);
    effect1->lpVtbl->Release(effect1);
}

Referenced by START_TEST().

test_effect_clear_vconsts()

static void test_effect_clear_vconsts ( IDirect3DDevice9 *  device )

static

Definition at line 2996 of file effect.c.

{
    unsigned int i;
    HRESULT hr;

    for (i = 0; i < 256; ++i)
    {
        hr = IDirect3DDevice9_SetVertexShaderConstantF(device, i, &fvect_filler.x, 1);
        ok(hr == D3D_OK, "Got result %#x.\n", hr);
    }
}

Referenced by test_effect_commitchanges(), test_effect_preshader(), test_effect_shared_parameters(), test_effect_skip_constants(), and test_effect_states().

test_effect_clone()

static void test_effect_clone ( void  )

static

Definition at line 7387 of file effect.c.

{
    IDirect3DDevice9 *device, *device2, *device3;
    ID3DXEffect *effect, *cloned;
    HWND window, window2;
    ULONG refcount;
    HRESULT hr;

    if (!(device = create_device(&window)))
        return;

    /* D3DXFX_NOT_CLONEABLE */
    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, D3DXFX_NOT_CLONEABLE, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->CloneEffect(effect, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#x.\n", hr);

    cloned = (void *)0xdeadbeef;
    hr = effect->lpVtbl->CloneEffect(effect, NULL, &cloned);
    ok(hr == E_FAIL, "Got result %#x.\n", hr);
    ok(cloned == (void *)0xdeadbeef, "Unexpected effect pointer.\n");

    hr = effect->lpVtbl->CloneEffect(effect, device, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#x.\n", hr);

    cloned = (void *)0xdeadbeef;
    hr = effect->lpVtbl->CloneEffect(effect, device, &cloned);
    ok(hr == E_FAIL, "Got result %#x.\n", hr);
    ok(cloned == (void *)0xdeadbeef, "Unexpected effect pointer.\n");

    effect->lpVtbl->Release(effect);

    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->CloneEffect(effect, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#x.\n", hr);

    cloned = (void *)0xdeadbeef;
    hr = effect->lpVtbl->CloneEffect(effect, NULL, &cloned);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#x.\n", hr);
    ok(cloned == (void *)0xdeadbeef, "Unexpected effect pointer.\n");

    hr = effect->lpVtbl->CloneEffect(effect, device, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->CloneEffect(effect, device, &cloned);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    todo_wine ok(cloned != effect, "Expected new effect instance.\n");
    cloned->lpVtbl->Release(cloned);
    /* Try with different device. */
    device2 = create_device(&window2);
    hr = effect->lpVtbl->CloneEffect(effect, device2, &cloned);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    todo_wine ok(cloned != effect, "Expected new effect instance.\n");

    hr = cloned->lpVtbl->GetDevice(cloned, &device3);
    ok(hr == S_OK, "Failed to get effect device.\n");
    todo_wine ok(device3 == device2, "Unexpected device instance, device3 %p, device2 %p.\n", device3, device2);
    IDirect3DDevice9_Release(device3);

    cloned->lpVtbl->Release(cloned);

    IDirect3DDevice9_Release(device2);
    DestroyWindow(window2);
    effect->lpVtbl->Release(effect);
    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %u references left.\n", refcount);
    DestroyWindow(window);
}

Referenced by START_TEST().

test_effect_commitchanges()

static void test_effect_commitchanges ( IDirect3DDevice9 *  device )

static

Definition at line 5366 of file effect.c.

{
    static const struct
    {
        const char *param_name;
        enum expected_state_update state_updated[ARRAY_SIZE(test_effect_preshader_op_expected)];
    }
    check_op_parameters[] =
    {
        {"opvect1", {EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED,
                     EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED,
                     EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED,
                     EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_ANYTHING,
                     EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED}},
        {"opvect2", {EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED,
                     EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED,
                     EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED,
                     EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_ANYTHING,
                     EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED, EXPECTED_STATE_UPDATED}},
        {"opvect3", {EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO,
                     EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO, EXPECTED_STATE_UPDATED,
                     EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO,
                     EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO, EXPECTED_STATE_ANYTHING,
                     EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO, EXPECTED_STATE_ZERO}},
    };
    static const struct
    {
        const char *param_name;
        const unsigned int const_updated_mask[(ARRAY_SIZE(test_effect_preshader_fvect_v)
                + TEST_EFFECT_BITMASK_BLOCK_SIZE - 1) / TEST_EFFECT_BITMASK_BLOCK_SIZE];
    }
    check_vconsts_parameters[] =
    {
        {"g_Selector", {0x00000000, 0x00000002}},
        {"g_Pos1",     {0x80000000, 0x00000002}},
        {"g_Pos2",     {0x00000000, 0x00000002}},
        {"m4x3column", {0x03800000, 0x00000000}},
        {"m3x4column", {0x000f0000, 0x00000000}},
        {"m4x3row",    {0x0000f000, 0x00000000}},
        {"m3x4row",    {0x00700000, 0x00000000}},
        {"ts1",        {0x1c000000, 0x00000000}},
        {"ts2",        {0x0000003f, 0x00000000}},
        {"arr1",       {0x00000000, 0x00000001}},
        {"arr2",       {0x60000000, 0x00000000}},
        {"ts3",        {0x00000fc0, 0x00000000}},
    };
    static const struct
    {
        const char *param_name;
        const unsigned int const_updated_mask[(ARRAY_SIZE(test_effect_preshader_bconsts)
                + TEST_EFFECT_BITMASK_BLOCK_SIZE - 1) / TEST_EFFECT_BITMASK_BLOCK_SIZE];
    }
    check_bconsts_parameters[] =
    {
        {"mb2x3row", {0x0000001f}},
        {"mb2x3column", {0x00000060}},
    };
    static const unsigned int const_no_update_mask[(ARRAY_SIZE(test_effect_preshader_fvect_v)
            + TEST_EFFECT_BITMASK_BLOCK_SIZE - 1) / TEST_EFFECT_BITMASK_BLOCK_SIZE];
    static const D3DLIGHT9 light_filler = {D3DLIGHT_POINT};

    ID3DXEffect *effect;
    HRESULT hr;
    D3DXHANDLE param;
    unsigned int i, passes_count, value;
    int ivect[4];
    D3DXVECTOR4 fvect;
    IDirect3DVertexShader9 *vshader;
    unsigned char buffer[256];


    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    param = effect->lpVtbl->GetParameterByName(effect, NULL, "g_iVect");
    ok(!!param, "GetParameterByName failed.\n");

    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    for (i = 0; i < ARRAY_SIZE(check_op_parameters); ++i)
    {
        unsigned int j;

        for (j = 0; j < 8; ++j)
        {
            hr = IDirect3DDevice9_SetLight(device, j, &light_filler);
            ok(hr == D3D_OK, "Got result %#x, i %u, j %u.\n", hr, i, j);
        }
        param = effect->lpVtbl->GetParameterByName(effect, NULL, check_op_parameters[i].param_name);
        ok(!!param, "Failed to get parameter (test %u).\n", i);
        hr = effect->lpVtbl->GetValue(effect, param, &fvect, sizeof(fvect));
        ok(hr == D3D_OK, "Failed to get parameter value, hr %#x (test %u).\n", hr, i);
        hr = effect->lpVtbl->SetValue(effect, param, &fvect, sizeof(fvect));
        ok(hr == D3D_OK, "Failed to set parameter value, hr %#x (test %u).\n", hr, i);
        hr = effect->lpVtbl->CommitChanges(effect);
        ok(hr == D3D_OK, "Failed to commit changes, hr %#x (test %u).\n", hr, i);

        test_effect_preshader_op_results(device, check_op_parameters[i].state_updated,
                check_op_parameters[i].param_name);
    }

    for (i = 0; i < ARRAY_SIZE(check_vconsts_parameters); ++i)
    {
        test_effect_clear_vconsts(device);
        param = effect->lpVtbl->GetParameterByName(effect, NULL, check_vconsts_parameters[i].param_name);
        ok(!!param, "GetParameterByName failed.\n");
        hr = effect->lpVtbl->GetValue(effect, param, buffer, sizeof(buffer));
        ok(hr == D3D_OK, "Got result %#x.\n", hr);
        hr = effect->lpVtbl->SetValue(effect, param, buffer, sizeof(buffer));
        ok(hr == D3D_OK, "Got result %#x.\n", hr);
        hr = effect->lpVtbl->CommitChanges(effect);
        ok(hr == D3D_OK, "Got result %#x.\n", hr);

        test_effect_preshader_compare_vconsts(device, check_vconsts_parameters[i].const_updated_mask,
                check_vconsts_parameters[i].param_name);
    }

    for (i = 0; i < ARRAY_SIZE(check_bconsts_parameters); ++i)
    {
        test_effect_preshader_clear_pbool_consts(device);
        param = effect->lpVtbl->GetParameterByName(effect, NULL, check_bconsts_parameters[i].param_name);
        ok(!!param, "GetParameterByName failed.\n");
        hr = effect->lpVtbl->GetValue(effect, param, buffer, sizeof(buffer));
        ok(hr == D3D_OK, "Got result %#x.\n", hr);
        hr = effect->lpVtbl->SetValue(effect, param, buffer, sizeof(buffer));
        ok(hr == D3D_OK, "Got result %#x.\n", hr);
        hr = effect->lpVtbl->CommitChanges(effect);
        ok(hr == D3D_OK, "Got result %#x.\n", hr);

        test_effect_preshader_compare_pbool_consts(device, check_bconsts_parameters[i].const_updated_mask,
                check_bconsts_parameters[i].param_name);
    }

    test_effect_clear_vconsts(device);
    param = effect->lpVtbl->GetParameterByName(effect, NULL, "g_Selector");
    ok(!!param, "GetParameterByName failed.\n");
    fvect.x = fvect.y = fvect.z = fvect.w = 0.0f;
    hr = effect->lpVtbl->SetVectorArray(effect, param, &fvect, 1);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_vconsts(device, check_vconsts_parameters[0].const_updated_mask,
                check_vconsts_parameters[0].param_name);

    test_effect_clear_vconsts(device);
    param = effect->lpVtbl->GetParameterByName(effect, NULL, "arr2");
    ok(!!param, "GetParameterByName failed.\n");
    param = effect->lpVtbl->GetParameterElement(effect, param, 0);
    ok(!!param, "GetParameterElement failed.\n");
    hr = effect->lpVtbl->SetFloat(effect, param, 92.0f);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_vconsts(device, const_no_update_mask,
                check_vconsts_parameters[10].param_name);

    test_effect_clear_vconsts(device);
    param = effect->lpVtbl->GetParameterByName(effect, NULL, "arr2");
    ok(!!param, "GetParameterByName failed.\n");
    param = effect->lpVtbl->GetParameterElement(effect, param, 1);
    ok(!!param, "GetParameterElement failed.\n");
    fvect.x = 93.0f;
    hr = effect->lpVtbl->SetValue(effect, param, &fvect.x, sizeof(fvect.x));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_vconsts(device, check_vconsts_parameters[10].const_updated_mask,
                check_vconsts_parameters[10].param_name);

    test_effect_clear_vconsts(device);
    param = effect->lpVtbl->GetParameterByName(effect, NULL, "arr2");
    ok(!!param, "GetParameterByName failed.\n");
    fvect.x = 92.0f;
    hr = effect->lpVtbl->SetFloatArray(effect, param, &fvect.x, 1);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_vconsts(device, check_vconsts_parameters[10].const_updated_mask,
                check_vconsts_parameters[10].param_name);

    test_effect_clear_vconsts(device);
    param = effect->lpVtbl->GetParameterByName(effect, NULL, "arr2");
    ok(!!param, "GetParameterByName failed.\n");
    param = effect->lpVtbl->GetParameterElement(effect, param, 1);
    ok(!!param, "GetParameterElement failed.\n");
    hr = effect->lpVtbl->SetInt(effect, param, 93);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_vconsts(device, const_no_update_mask,
                check_vconsts_parameters[10].param_name);

    test_effect_clear_vconsts(device);
    param = effect->lpVtbl->GetParameterByName(effect, NULL, "g_Pos1");
    ok(!!param, "GetParameterByName failed.\n");
    fvect.x = fvect.y = fvect.z = fvect.w = 0.0f;
    hr = effect->lpVtbl->SetVector(effect, param, &fvect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_vconsts(device, check_vconsts_parameters[1].const_updated_mask,
                check_vconsts_parameters[1].param_name);

    test_effect_clear_vconsts(device);
    param = effect->lpVtbl->GetParameterByName(effect, NULL, "ts1");
    ok(!!param, "GetParameterByName failed.\n");
    param = effect->lpVtbl->GetParameterElement(effect, param, 0);
    ok(!!param, "GetParameterByName failed.\n");
    param = effect->lpVtbl->GetParameterByName(effect, param, "fv");
    ok(!!param, "GetParameterByName failed.\n");
    fvect.x = 12;
    hr = effect->lpVtbl->SetValue(effect, param, &fvect.x, sizeof(float));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_vconsts(device, check_vconsts_parameters[7].const_updated_mask,
                check_vconsts_parameters[7].param_name);

    *(float *)&value = 9999.0f;
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGDENSITY, value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSCALE_A, value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSCALE_B, value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_clear_vconsts(device);
    param = effect->lpVtbl->GetParameterByName(effect, NULL, "ts2");
    ok(!!param, "GetParameterByName failed.\n");
    param = effect->lpVtbl->GetParameterElement(effect, param, 0);
    ok(!!param, "GetParameterByName failed.\n");
    param = effect->lpVtbl->GetParameterByName(effect, param, "v1");
    ok(!!param, "GetParameterByName failed.\n");
    hr = effect->lpVtbl->GetValue(effect, param, &fvect, sizeof(float) * 3);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->SetValue(effect, param, &fvect, sizeof(float) * 3);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_FOGDENSITY, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(value == 0, "Unexpected fog density %g.\n", *(float *)&value);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_FOGSTART, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(*(float *)&value == 4.0f, "Unexpected fog start %g.\n", *(float *)&value);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSCALE_A, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(*(float *)&value == 9999.0f, "Unexpected point scale A %g.\n", *(float *)&value);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSCALE_B, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(*(float *)&value == 9999.0f, "Unexpected point scale B %g.\n", *(float *)&value);
    test_effect_preshader_compare_vconsts(device, check_vconsts_parameters[8].const_updated_mask,
                check_vconsts_parameters[8].param_name);

    *(float *)&value = 9999.0f;
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGDENSITY, value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSCALE_A, value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSCALE_B, value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_clear_vconsts(device);
    param = effect->lpVtbl->GetParameterByName(effect, NULL, "ts3");
    ok(!!param, "GetParameterByName failed.\n");
    param = effect->lpVtbl->GetParameterByName(effect, param, "ts");
    ok(!!param, "GetParameterByName failed.\n");
    param = effect->lpVtbl->GetParameterElement(effect, param, 1);
    ok(!!param, "GetParameterByName failed.\n");
    param = effect->lpVtbl->GetParameterByName(effect, param, "fv");
    ok(!!param, "GetParameterByName failed.\n");
    hr = effect->lpVtbl->GetValue(effect, param, &fvect.x, sizeof(float));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->SetValue(effect, param, &fvect.x, sizeof(float));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_FOGDENSITY, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(*(float *)&value == 9999.0f, "Unexpected fog density %g.\n", *(float *)&value);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_FOGSTART, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(*(float *)&value == 9999.0f, "Unexpected fog start %g.\n", *(float *)&value);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSCALE_A, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(*(float *)&value == 4.0f, "Unexpected point scale A %g.\n", *(float *)&value);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSCALE_B, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(*(float *)&value == 12.0f, "Unexpected point scale B %g.\n", *(float *)&value);
    test_effect_preshader_compare_vconsts(device, check_vconsts_parameters[11].const_updated_mask,
                check_vconsts_parameters[11].param_name);

    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER0, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(value == 1, "Unexpected sampler 0 minfilter %u.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER1, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    todo_wine
    ok(value == 0, "Unexpected sampler 1 minfilter %u.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER2, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(value == 3, "Unexpected sampler 2 minfilter %u.\n", value);

    param = effect->lpVtbl->GetParameterByName(effect, NULL, "g_iVect");
    ok(!!param, "GetParameterByName failed.\n");
    ivect[0] = ivect[1] = ivect[2] = ivect[3] = 1;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    for (i = 0; i < 3; ++i)
    {
        hr = IDirect3DDevice9_SetSamplerState(device, D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_MINFILTER, 0);
        ok(hr == D3D_OK, "Got result %#x.\n", hr);
        hr = IDirect3DDevice9_SetSamplerState(device, D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_MAGFILTER, 0);
        ok(hr == D3D_OK, "Got result %#x.\n", hr);
    }

    hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, 0);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, 0);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_clear_vconsts(device);

    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!vshader, "Got non NULL vshader.\n");
    test_effect_preshader_compare_vconsts(device, const_no_update_mask,
            "selector g_iVect");

    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER0, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(value == 0, "Unexpected sampler 0 minfilter %u.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER1, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(value == 0, "Unexpected sampler 1 minfilter %u.\n", value);

    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER2, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(value == 1, "Unexpected sampler 2 minfilter %u.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER2, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(value == 0, "Unexpected sampler 2 minfilter %u.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(value == 1, "Unexpected sampler 0 minfilter %u.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(value == 0, "Unexpected sampler 0 minfilter %u.\n", value);

    ivect[3] = 2;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ivect[3] = 1;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!vshader, "Got non NULL vshader.\n");
    test_effect_preshader_compare_vconsts(device, const_no_update_mask,
            "selector g_iVect");
    ivect[3] = 2;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!!vshader, "Got NULL vshader.\n");
    IDirect3DVertexShader9_Release(vshader);
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 0, &fvect.x, 1);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(fvect.x == 0.0f && fvect.y == 0.0f && fvect.z == 0.0f && fvect.w == 0.0f,
            "Vertex shader float constants do not match.\n");
    hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, &fvect_filler.x, 1);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_vconsts(device, const_no_update_mask,
            "selector g_iVect");
    ivect[3] = 1;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_vconsts(device, NULL, NULL);

    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    effect->lpVtbl->Release(effect);
}

Referenced by START_TEST().

test_effect_compilation_errors()

static void test_effect_compilation_errors ( IDirect3DDevice9 *  device )

static

Definition at line 2865 of file effect.c.

{
    ID3DXEffect *effect;
    ID3DXBuffer *compilation_errors;
    HRESULT hr;

    /* Test binary effect */
    compilation_errors = (ID3DXBuffer*)0xdeadbeef;
    hr = D3DXCreateEffect(NULL, NULL, 0, NULL, NULL, 0, NULL, NULL, &compilation_errors);
    ok(hr == D3DERR_INVALIDCALL, "D3DXCreateEffect failed, got %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
    ok(!compilation_errors, "Returned %p\n", compilation_errors);

    compilation_errors = (ID3DXBuffer*)0xdeadbeef;
    hr = D3DXCreateEffect(device, test_effect_variable_names_blob,
            sizeof(test_effect_variable_names_blob), NULL, NULL, 0, NULL, &effect, &compilation_errors);
    ok(hr == D3D_OK, "D3DXCreateEffect failed, got %#x, expected %#x\n", hr, D3D_OK);
    ok(!compilation_errors, "Returned %p\n", compilation_errors);
    effect->lpVtbl->Release(effect);
}

Referenced by START_TEST().

test_effect_find_next_valid_technique()

static void test_effect_find_next_valid_technique ( void  )

static

Definition at line 7899 of file effect.c.

{
    D3DPRESENT_PARAMETERS present_parameters = {0};
    IDirect3DDevice9 *device;
    D3DXTECHNIQUE_DESC desc;
    ID3DXEffect *effect;
    IDirect3D9 *d3d;
    D3DXHANDLE tech;
    ULONG refcount;
    HWND window;
    HRESULT hr;

    if (!(window = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
            640, 480, NULL, NULL, NULL, NULL)))
    {
        skip("Failed to create window.\n");
        return;
    }
    if (!(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
    {
        skip("Failed to create IDirect3D9 object.\n");
        DestroyWindow(window);
        return;
    }
    present_parameters.Windowed = TRUE;
    present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
    hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
            D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device);
    if (FAILED(hr))
    {
        skip("Failed to create IDirect3DDevice9 object, hr %#x.\n", hr);
        IDirect3D9_Release(d3d);
        DestroyWindow(window);
        return;
    }

    hr = D3DXCreateEffectEx(device, test_two_techniques_blob, sizeof(test_two_techniques_blob),
            NULL, NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->FindNextValidTechnique(effect, NULL, &tech);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!strcmp(desc.Name, "tech0"), "Got unexpected technique %s.\n", desc.Name);

    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!strcmp(desc.Name, "tech1"), "Got unexpected technique %s.\n", desc.Name);

    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech);
    ok(hr == S_FALSE, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!strcmp(desc.Name, "tech0"), "Got unexpected technique %s.\n", desc.Name);

    effect->lpVtbl->Release(effect);

    hr = D3DXCreateEffectEx(device, test_effect_unsupported_shader_blob, sizeof(test_effect_unsupported_shader_blob),
            NULL, NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->FindNextValidTechnique(effect, NULL, &tech);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!strcmp(desc.Name, "tech1"), "Got unexpected technique %s.\n", desc.Name);

    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech);
    ok(hr == S_FALSE, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!strcmp(desc.Name, "tech0"), "Got unexpected technique %s.\n", desc.Name);

    hr = effect->lpVtbl->SetInt(effect, "i", 1);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    tech = (D3DXHANDLE)0xdeadbeef;
    hr = effect->lpVtbl->FindNextValidTechnique(effect, NULL, &tech);
    ok(hr == S_FALSE, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!strcmp(desc.Name, "tech0"), "Got unexpected technique %s.\n", desc.Name);

    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech);
    ok(hr == S_FALSE, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->SetInt(effect, "i", 0);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);

    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!strcmp(desc.Name, "tech1"), "Got unexpected technique %s.\n", desc.Name);

    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech);
    ok(hr == S_FALSE, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->FindNextValidTechnique(effect, "nope", &tech);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#x.\n", hr);

    effect->lpVtbl->Release(effect);

    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %u references left.\n", refcount);
    IDirect3D9_Release(d3d);
    DestroyWindow(window);
}

Referenced by START_TEST().

test_effect_get_pass_desc()

static void test_effect_get_pass_desc ( IDirect3DDevice9 *  device )

static

Definition at line 6909 of file effect.c.

{
    unsigned int passes_count;
    ID3DXEffect *effect;
    D3DXPASS_DESC desc;
    D3DXVECTOR4 fvect;
    D3DXHANDLE pass;
    HRESULT hr;

    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    pass = effect->lpVtbl->GetPass(effect, "tech0", 1);
    ok(!!pass, "GetPass() failed.\n");

    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_shader_bytecode(desc.pVertexShaderFunction, 0, 2, FALSE);

    fvect.x = fvect.y = fvect.w = 0.0f;
    fvect.z = 0.0f;
    hr = effect->lpVtbl->SetVector(effect, "g_iVect", &fvect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!desc.pPixelShaderFunction, "Unexpected non null desc.pPixelShaderFunction.\n");

    test_effect_preshader_compare_shader_bytecode(desc.pVertexShaderFunction, 0, 0, FALSE);

    fvect.z = 3.0f;
    hr = effect->lpVtbl->SetVector(effect, "g_iVect", &fvect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == E_FAIL, "Got result %#x.\n", hr);
    ok(!desc.pVertexShaderFunction, "Unexpected non null desc.pVertexShaderFunction.\n");

    /* Repeating call to confirm GetPassDesc() returns same error on the second call,
     * as it is not the case sometimes for BeginPass() with out of bound access. */
    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == E_FAIL, "Got result %#x.\n", hr);
    ok(!desc.pVertexShaderFunction, "Unexpected non null desc.pVertexShaderFunction.\n");

    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    test_effect_preshader_compare_shader_bytecode(desc.pVertexShaderFunction, 0, 0, FALSE);

    fvect.z = 2.0f;
    hr = effect->lpVtbl->SetVector(effect, "g_iVect", &fvect);
    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_shader_bytecode(desc.pVertexShaderFunction, 0, 2, FALSE);

    effect->lpVtbl->Release(effect);

    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, D3DXFX_NOT_CLONEABLE, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    pass = effect->lpVtbl->GetPass(effect, "tech0", 1);
    ok(!!pass, "GetPass() failed.\n");

    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    ok(!desc.pVertexShaderFunction, "Unexpected non null desc.pVertexShaderFunction.\n");
    ok(!desc.pPixelShaderFunction, "Unexpected non null desc.pPixelShaderFunction.\n");

    effect->lpVtbl->Release(effect);
}

Referenced by START_TEST().

test_effect_isparameterused()

static void test_effect_isparameterused ( IDirect3DDevice9 *  device )

static

Definition at line 5155 of file effect.c.

{
    static const struct
    {
        const char *name;
        BOOL expected_result;
    }
    check_parameters[] =
    {
        {"g_Pos1", TRUE},
        {"g_Pos2", TRUE},
        {"g_Selector", TRUE},
        {"opvect1", TRUE},
        {"opvect2", TRUE},
        {"opvect3", TRUE},
        {"arr2", TRUE},
        {"vs_arr", TRUE},
        {"g_iVect", TRUE},
        {"vect_sampler", TRUE},
        {"tex1", TRUE},
        {"tex2", FALSE},
        {"sampler1", TRUE},
        {"ts1", TRUE},
        {"ts2", TRUE},
        {"ts3", TRUE},
    };
    ID3DXEffect *effect, *effect2;
    HRESULT hr;
    D3DXHANDLE tech;
    unsigned int i;

    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    tech = effect->lpVtbl->GetTechniqueByName(effect, "tech0");
    ok(!!tech, "GetTechniqueByName failed.\n");

    for (i = 0; i < ARRAY_SIZE(check_parameters); ++i)
        test_isparameterused_param_with_children(effect, NULL, tech, check_parameters[i].name,
                check_parameters[i].expected_result);

    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, 0, NULL, &effect2, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    for (i = 0; i < ARRAY_SIZE(check_parameters); ++i)
        test_isparameterused_param_with_children(effect, effect2, tech, check_parameters[i].name,
                check_parameters[i].expected_result);

    effect2->lpVtbl->Release(effect2);

    hr = D3DXCreateEffect(device, test_effect_states_effect_blob, sizeof(test_effect_states_effect_blob),
            NULL, NULL, 0, NULL, &effect2, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    test_isparameterused_param_with_children(effect, effect2, tech, "sampler1", TRUE);
    effect2->lpVtbl->Release(effect2);

    effect->lpVtbl->Release(effect);
}

Referenced by START_TEST().

test_effect_large_address_aware_flag()

static void test_effect_large_address_aware_flag ( IDirect3DDevice9 *  device )

static

Definition at line 6876 of file effect.c.

{
    ID3DXEffect *effect;
    D3DXHANDLE param;
    static int expected_ivect[4] = {28, 29, 30, 31};
    int ivect[4];
    HRESULT hr;

    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, D3DXFX_LARGEADDRESSAWARE, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    param = effect->lpVtbl->GetParameterByName(effect, NULL, "g_iVect");
    ok(!!param, "GetParameterByName failed.\n");

    hr = effect->lpVtbl->SetValue(effect, param, expected_ivect, sizeof(expected_ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->GetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    ok(!memcmp(ivect, expected_ivect, sizeof(expected_ivect)), "Vector value mismatch.\n");

    if (0)
    {
        /* Native d3dx crashes in GetValue(). */
        hr = effect->lpVtbl->GetValue(effect, "g_iVect", ivect, sizeof(ivect));
        ok(hr == D3DERR_INVALIDCALL, "Got result %#x.\n", hr);
    }

    effect->lpVtbl->Release(effect);
}

Referenced by START_TEST().

test_effect_null_shader()

static void test_effect_null_shader ( void  )

static

Definition at line 7332 of file effect.c.

{
    IDirect3DDevice9 *device;
    ID3DXEffect *effect;
    D3DXPASS_DESC desc;
    D3DXHANDLE pass;
    ULONG refcount;
    HWND window;
    HRESULT hr;

    /* Creating a fresh device because the existing device can have invalid
     * render states from previous tests. If IDirect3DDevice9_ValidateDevice()
     * returns certain error codes, native ValidateTechnique() fails. */
    if (!(device = create_device(&window)))
        return;

    hr = D3DXCreateEffectEx(device, test_effect_null_shader_blob,
            sizeof(test_effect_null_shader_blob), NULL, NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Failed to create effect, hr %#x.\n", hr);

    pass = effect->lpVtbl->GetPass(effect, "tech0", 0);
    ok(!!pass, "GetPass() failed.\n");
    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!desc.pVertexShaderFunction, "Got non NULL vertex function.\n");

    pass = effect->lpVtbl->GetPass(effect, "tech1", 0);
    ok(!!pass, "GetPass() failed.\n");
    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!desc.pVertexShaderFunction, "Got non NULL vertex function.\n");

    hr = effect->lpVtbl->ValidateTechnique(effect, "tech0");
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->SetInt(effect, "i", 0);
    ok(hr == D3D_OK, "Failed to set parameter, hr %#x.\n", hr);
    hr = effect->lpVtbl->ValidateTechnique(effect, "tech1");
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->SetInt(effect, "i", 1);
    ok(hr == D3D_OK, "Failed to set parameter, hr %#x.\n", hr);
    hr = effect->lpVtbl->ValidateTechnique(effect, "tech1");
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->SetInt(effect, "i", 2);
    ok(hr == D3D_OK, "Failed to set parameter, hr %#x.\n", hr);
    hr = effect->lpVtbl->ValidateTechnique(effect, "tech1");
    ok(hr == E_FAIL, "Got result %#x.\n", hr);

    effect->lpVtbl->Release(effect);

    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %u references left.\n", refcount);
    DestroyWindow(window);
}

Referenced by START_TEST().

test_effect_out_of_bounds_selector()

static void test_effect_out_of_bounds_selector ( IDirect3DDevice9 *  device )

static

Definition at line 5217 of file effect.c.

{
    ID3DXEffect *effect;
    HRESULT hr;
    D3DXHANDLE param;
    int ivect[4];
    unsigned int passes_count;
    IDirect3DVertexShader9 *vshader;

    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, 0, NULL, &effect, NULL);

    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    ivect[0] = ivect[1] = ivect[3] = 1;

    param = effect->lpVtbl->GetParameterByName(effect, NULL, "g_iVect");
    ok(!!param, "GetParameterByName failed.\n");
    ivect[2] = 3;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == E_FAIL, "Got result %#x.\n", hr);

    /* Second try reports success and selects array element used previously.
     * Probably array index is not recomputed and previous index value is used. */
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_shader(device, 2, FALSE);

    /* Confirm that array element selected is the previous good one and does not depend
     * on computed (out of bound) index value. */
    ivect[2] = 1;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_shader(device, 1, FALSE);
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ivect[2] = 3;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == E_FAIL, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_shader(device, 1, FALSE);

    /* End and begin effect again to ensure it will not trigger array
     * index recompute and error return from BeginPass. */
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    test_effect_preshader_compare_shader(device, 1, FALSE);
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);


    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    ivect[2] = -2;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == E_FAIL, "Got result %#x.\n", hr);

    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!vshader, "Got non NULL vshader.\n");

    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    test_effect_preshader_compare_shader(device, 1, FALSE);

    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    ivect[2] = -1;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    test_effect_preshader_compare_shader(device, 0, FALSE);

    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    ivect[2] = 3;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!vshader, "Got non NULL vshader.\n");

    ivect[2] = -1;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    ok(!vshader, "Got non NULL vshader.\n");

    ivect[2] = 1;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    test_effect_preshader_compare_shader(device, 1, FALSE);

    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    effect->lpVtbl->Release(effect);
}

Referenced by START_TEST().

test_effect_parameter_block()

static void test_effect_parameter_block ( void  )

static

Definition at line 8011 of file effect.c.

{
    static const D3DXMATRIX test_mat =
    {{{
        -11.0f, -12.0f, 0.0f, 0.0f,
        -21.0f, -22.0f, 0.0f, 0.0f,
        -31.0f, -32.0f, 0.0f, 0.0f,
    }}};
    static const D3DXMATRIX effect_orig_mat =
    {{{
        11.0f, 12.0f, 0.0f, 0.0f,
        21.0f, 22.0f, 0.0f, 0.0f,
        31.0f, 32.0f, 0.0f, 0.0f,
    }}};
    D3DPRESENT_PARAMETERS present_parameters = {0};
    static const float float_array_zero[4];
    IDirect3DTexture9 *texture, *tex_test;
    D3DXHANDLE block, block2, handle;
    ID3DXEffect *effect, *effect2;
    D3DXMATRIX mat, mat_arr[2];
    IDirect3DDevice9 *device;
    ID3DXEffectPool *pool;
    float float_array[4];
    float float_value;
    IDirect3D9 *d3d;
    ULONG refcount;
    HWND window;
    HRESULT hr;

    if (!(window = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0,
            640, 480, NULL, NULL, NULL, NULL)))
    {
        skip("Failed to create window.\n");
        return;
    }
    if (!(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
    {
        skip("Failed to create IDirect3D9 object.\n");
        DestroyWindow(window);
        return;
    }
    present_parameters.Windowed = TRUE;
    present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
    hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
            D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device);
    if (FAILED(hr))
    {
        skip("Failed to create IDirect3DDevice9 object, hr %#x.\n", hr);
        IDirect3D9_Release(d3d);
        DestroyWindow(window);
        return;
    }

    hr = D3DXCreateEffectPool(&pool);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, 0, pool, &effect, NULL);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, 0, pool, &effect2, NULL);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);

    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
    block = effect->lpVtbl->EndParameterBlock(effect);
    ok(!!block, "Got unexpected block %p.\n", block);
    handle = effect->lpVtbl->EndParameterBlock(effect);
    ok(!handle, "Got unexpected handle %p.\n", handle);

    /* Block doesn't hold effect reference. */
    effect->lpVtbl->AddRef(effect);
    refcount = effect->lpVtbl->Release(effect);
    ok(refcount == 1, "Got unexpected refcount %u.\n", refcount);

    hr = effect->lpVtbl->ApplyParameterBlock(effect, block);
    ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->DeleteParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "vec3[0]", 1001.0f);
    ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "arr1[0]", 91.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    block = effect->lpVtbl->EndParameterBlock(effect);
    ok(!!block, "Got unexpected block %p.\n", block);
    hr = effect->lpVtbl->ApplyParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);

    hr = effect->lpVtbl->DeleteParameterBlock(effect2, block);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#x.\n", hr);
    hr = effect->lpVtbl->DeleteParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    hr = effect->lpVtbl->ApplyParameterBlock(effect, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->ApplyParameterBlock(effect, "parameter_block");
    ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr);

    hr = D3DXCreateTexture(device, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, 0, D3DPOOL_DEFAULT, &texture);
    ok(hr == D3D_OK, "Got result %#x, expected 0 (D3D_OK).\n", hr);

    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);

    /* Effect parameters are not updated during recording. */
    hr = effect->lpVtbl->SetTexture(effect, "tex1", (IDirect3DBaseTexture9 *)texture);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);

    hr = effect->lpVtbl->GetTexture(effect, "tex1", (IDirect3DBaseTexture9 **)&tex_test);
    ok(hr == D3D_OK && !tex_test, "Got unexpected hr %#x, tex_test %p.\n", hr, tex_test);

    /* Child parameters and array members are recorded separately (the whole
     * parameter is not updated when parameter block is applied). */
    hr = effect->lpVtbl->SetFloat(effect, "arr2[0]", 92.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "ts1[0].fv", 28.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->GetFloat(effect, "ts1[0].fv", &float_value);
    ok(hr == D3D_OK && float_value == 12.0, "Got unexpected hr %#x, float_value %g.\n", hr, float_value);

    float_array[0] = -29.0f;
    hr = effect->lpVtbl->SetFloatArray(effect, "ts1[0].v2", float_array, 1);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->GetFloatArray(effect, "ts1[0].v2", float_array, 1);
    ok(hr == D3D_OK && float_array[0] == 13.0, "Got unexpected hr %#x, float_array[0] %g.\n",
            hr, float_array[0]);

    memset(&mat, 0, sizeof(mat));
    hr = effect->lpVtbl->SetMatrix(effect, "m3x2row", &test_mat);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->GetMatrix(effect, "m3x2row", &mat);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    ok(!memcmp(&mat, &effect_orig_mat, sizeof(mat)), "Got unexpected matrix.\n");

    hr = effect->lpVtbl->SetMatrix(effect, "m3x2column", &test_mat);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->GetMatrix(effect, "m3x2column", &mat);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    ok(!memcmp(&mat, &effect_orig_mat, sizeof(mat)), "Got unexpected matrix.\n");

    /* Setting shared parameter through effect2 is not recorded to effect
     * parameter block. */
    hr = effect2->lpVtbl->SetFloat(effect2, "arr2[1]", -1.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->GetFloat(effect, "arr2[1]", &float_value);
    ok(float_value == -1.0f, "Unexpected value %g.\n", float_value);

    IDirect3DTexture9_AddRef(texture);
    refcount = IDirect3DTexture9_Release(texture);
    ok(refcount == 2, "Got unexpected refcount %u.\n", refcount);

    block = effect->lpVtbl->EndParameterBlock(effect);
    ok(!!block, "Got unexpected block %p.\n", block);

    IDirect3DTexture9_AddRef(texture);
    refcount = IDirect3DTexture9_Release(texture);
    ok(refcount == 2, "Got unexpected refcount %u.\n", refcount);

    hr = effect->lpVtbl->DeleteParameterBlock(effect2, block);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#x.\n", hr);

    IDirect3DTexture9_AddRef(texture);
    refcount = IDirect3DTexture9_Release(texture);
    ok(refcount == 2, "Got unexpected refcount %u.\n", refcount);

    hr = effect->lpVtbl->SetFloat(effect, "arr2[0]", 0.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "arr2[1]", 0.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetFloatArray(effect, "ts1[0].v1", float_array_zero, 3);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "ts1[0].fv", 0.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetFloatArray(effect, "ts1[0].v2", float_array_zero, 4);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    memset(&mat, 0, sizeof(mat));
    hr = effect->lpVtbl->SetMatrix(effect, "m3x2row", &mat);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetMatrix(effect, "m3x2column", &mat);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);

    hr = effect->lpVtbl->ApplyParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got result %#x.\n", hr);

    IDirect3DTexture9_AddRef(texture);
    refcount = IDirect3DTexture9_Release(texture);
    ok(refcount == 3, "Got unexpected refcount %u.\n", refcount);

    hr = effect->lpVtbl->GetFloat(effect, "arr2[0]", &float_value);
    ok(hr == D3D_OK && float_value == 92.0f, "Got unexpected hr %#x, float_value %g.\n", hr, float_value);
    hr = effect->lpVtbl->GetFloat(effect, "arr2[1]", &float_value);
    ok(hr == D3D_OK && float_value == 0.0f, "Got unexpected hr %#x, float_value %g.\n", hr, float_value);

    hr = effect->lpVtbl->GetFloatArray(effect, "ts1[0].v1", float_array, 3);
    ok(hr == D3D_OK && !memcmp(float_array, float_array_zero, 3 * sizeof(*float_array)),
            "Got unexpected hr %#x, ts1[0].v1 (%g, %g, %g).\n", hr,
            float_array[0], float_array[1], float_array[2]);

    hr = effect->lpVtbl->GetMatrix(effect, "m3x2row", &mat);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    ok(!memcmp(&mat, &test_mat, sizeof(mat)), "Got unexpected matrix.\n");
    hr = effect->lpVtbl->GetMatrix(effect, "m3x2column", &mat);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    ok(!memcmp(&mat, &test_mat, sizeof(mat)), "Got unexpected matrix.\n");

    hr = effect->lpVtbl->GetFloat(effect, "ts1[0].fv", &float_value);
    ok(hr == D3D_OK && float_value == 28.0f, "Got unexpected hr %#x, float_value %g.\n", hr, float_value);

    hr = effect->lpVtbl->GetFloatArray(effect, "ts1[0].v2", float_array, 4);
    ok(hr == D3D_OK && float_array[0] == -29.0f
            && !memcmp(float_array + 1, float_array_zero, 3 * sizeof(*float_array)),
            "Got unexpected hr %#x, ts1[0].v2 (%g, %g, %g, %g).\n", hr,
            float_array[0], float_array[1], float_array[2], float_array[3]);

    /* Test applying a parameter block while recording a new one. */
    hr = effect->lpVtbl->SetFloat(effect, "arr2[0]", 0.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "arr2[1]", 0.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetFloatArray(effect, "ts1[0].v1", float_array_zero, 3);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "ts1[0].fv", 0.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetFloatArray(effect, "ts1[0].v2", float_array_zero, 4);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    memset(&mat, 0, sizeof(mat));
    hr = effect->lpVtbl->SetMatrix(effect, "m3x2row", &effect_orig_mat);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->SetMatrix(effect, "m3x2column", &effect_orig_mat);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);

    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
    hr = effect->lpVtbl->ApplyParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);

    hr = effect->lpVtbl->GetFloat(effect, "arr2[0]", &float_value);
    ok(hr == D3D_OK && float_value == 0.0f, "Got unexpected hr %#x, float_value