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(...)    test_isparameterused_param_with_children_(__LINE__, __VA_ARGS__)
#define	INITIAL_UPDATE_RECORD_SIZE   64
#define	test_effect_shared_vs_arr_compare_helper(...)    test_effect_shared_vs_arr_compare_helper_(__LINE__, __VA_ARGS__)
#define	test_effect_shared_parameters_compare_vconst(...)    test_effect_shared_parameters_compare_vconst_(__LINE__, __VA_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_uint (unsigned int x, unsigned int y, unsigned int max_diff)
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)
static void	test_effect_parameter_value_GetBool (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetBoolArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetInt (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetIntArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetFloat (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetFloatArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetVector (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetVectorArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetMatrix (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetMatrixArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetMatrixPointerArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetMatrixTranspose (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetMatrixTransposeArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_GetMatrixTransposePointerArray (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_values (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
static void	test_effect_parameter_value_reset (const struct test_effect_parameter_value_result *res, ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter)
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 []
static const struct test_effect_parameter_value_result	test_effect_parameter_value_result_float []
static const DWORD	test_effect_parameter_value_blob_int []
static const struct test_effect_parameter_value_result	test_effect_parameter_value_result_int []
static const DWORD	test_effect_parameter_value_blob_object []
static const struct test_effect_parameter_value_result	test_effect_parameter_value_result_object []
static const DWORD	test_effect_parameter_value_blob_special []
static const 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 1143 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 1168 of file effect.c.

INITIAL_UPDATE_RECORD_SIZE

#define INITIAL_UPDATE_RECORD_SIZE   64

Definition at line 6249 of file effect.c.

INT_FLOAT_MULTI

#define INT_FLOAT_MULTI   255.0f

Definition at line 1170 of file effect.c.

INT_FLOAT_MULTI_INVERSE

#define INT_FLOAT_MULTI_INVERSE   (1/INT_FLOAT_MULTI)

Definition at line 1171 of file effect.c.

TEST_EFFECT_BITMASK_BLOCK_SIZE

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

Definition at line 4582 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 4652 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 4429 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 4402 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 4584 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 4506 of file effect.c.

TEST_EFFECT_PRESHADER_VSHADER_LEN

#define TEST_EFFECT_PRESHADER_VSHADER_LEN   13

Definition at line 4400 of file effect.c.

TEST_EFFECT_PRESHADER_VSHADER_POS

#define TEST_EFFECT_PRESHADER_VSHADER_POS   2991

Definition at line 4399 of file effect.c.

test_effect_shared_parameters_compare_vconst

#define test_effect_shared_parameters_compare_vconst

(

...

)

test_effect_shared_parameters_compare_vconst_(__LINE__, __VA_ARGS__)

Definition at line 6758 of file effect.c.

test_effect_shared_vs_arr_compare_helper

#define test_effect_shared_vs_arr_compare_helper

(

...

)

test_effect_shared_vs_arr_compare_helper_(__LINE__, __VA_ARGS__)

Definition at line 6737 of file effect.c.

TEST_EFFECT_STATES_VSHADER_POS

#define TEST_EFFECT_STATES_VSHADER_POS   315

Definition at line 3119 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 7391 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 7390 of file effect.c.

test_isparameterused_param_with_children

#define test_isparameterused_param_with_children

(

...

)

test_isparameterused_param_with_children_(__LINE__, __VA_ARGS__)

Definition at line 5284 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 4499 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 33 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;
 
    return compare_uint(x, y, ulps);
}

compare_uint()

static BOOL compare_uint ( unsigned int  x, unsigned int  y, unsigned int  max_diff  )

static

Definition at line 26 of file effect.c.

{
    unsigned int diff = x > y ? x - y : y - x;
 
    return diff <= max_diff;
}

Referenced by compare_float().

compare_update_record()

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

static

Definition at line 6478 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 135 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 %#lx.\n", hr);
        DestroyWindow(wnd);
        return NULL;
    }
 
    *window = wnd;
    return device;
}

create_directory()

static BOOL create_directory ( const char *  name )

static

Definition at line 214 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 177 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;
}

d3dxinclude_close()

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

static

Definition at line 8106 of file effect.c.

{
    free((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 8024 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;
 
    if (winetest_debug > 1)
    {
        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 = malloc(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 = malloc(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 = malloc(sizeof(include2));
        memcpy(buffer, include2, sizeof(include2));
        *bytes = sizeof(include2);
        /* d3dx9_36 passes parent_data even for includes from the main file. */
        ok(!parent_data || (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 223 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 205 of file effect.c.

{
    char path[MAX_PATH];
 
    strcpy(path, temp_path);
    strcat(path, filename);
    DeleteFileA(path);
}

free_test_effect_state_manager()

static void free_test_effect_state_manager ( struct test_manager *  state_manager )

static

Definition at line 6256 of file effect.c.

{
    free(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 100 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 73 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 46 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 7907 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 6251 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 105 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;
    }
}

START_TEST()

START_TEST

(

effect

)

Definition at line 8893 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 %lu 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 237 of file effect.c.

{
    D3DXEFFECT_DESC desc;
    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 %lx, expected %lx (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateEffect(device, NULL, 0, NULL, NULL, 0, NULL, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %lx, expected %lx (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateEffect(device, effect_desc, 0, NULL, NULL, 0, NULL, NULL, NULL);
    ok(hr == E_FAIL, "Got result %lx, expected %lx (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 %lx, expected 0 (D3D_OK)\n", hr);
 
    hr = D3DXCreateEffect(device, effect_desc, sizeof(effect_desc), NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %lx, expected 0 (D3D_OK)\n", hr);
 
    hr = effect->lpVtbl->GetDesc(effect, &desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", desc.Creator);
    ok(!desc.Functions, "Unexpected value %u.\n", desc.Functions);
    ok(desc.Techniques == 1, "Unexpected value %u.\n", desc.Techniques);
    ok(!desc.Parameters, "Unexpected value %u.\n", desc.Parameters);
 
    hr = effect->lpVtbl->QueryInterface(effect, &IID_ID3DXBaseEffect, (void **)&base);
    ok(hr == E_NOINTERFACE, "QueryInterface failed, got %lx, expected %lx (E_NOINTERFACE)\n", hr, E_NOINTERFACE);
 
    hr = effect->lpVtbl->GetStateManager(effect, NULL);
    ok(hr == D3DERR_INVALIDCALL, "GetStateManager failed, got %lx, expected %lx (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = effect->lpVtbl->GetStateManager(effect, &manager);
    ok(hr == D3D_OK, "GetStateManager failed, got %lx, 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 %lx, expected 0 (D3D_OK)\n", hr);
 
    hr = effect->lpVtbl->GetStateManager(effect, &manager);
    ok(hr == D3D_OK, "GetStateManager failed, got %lx, 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 %lu, expected 4\n", count);
 
    count = IUnknown_Release(manager);
    ok(count == 3, "Release failed, got %lu, expected 3\n", count);
 
    hr = effect->lpVtbl->SetStateManager(effect, NULL);
    ok(hr == D3D_OK, "SetStateManager failed, got %lx, expected 0 (D3D_OK)\n", hr);
 
    hr = effect->lpVtbl->GetPool(effect, &pool);
    ok(hr == D3D_OK, "GetPool failed, got %lx, 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 %lx, expected %lx (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = effect->lpVtbl->GetDevice(effect, &device2);
    ok(hr == D3D_OK, "Got result %lx, expected 0 (D3D_OK)\n", hr);
 
    hr = effect->lpVtbl->GetDevice(effect, NULL);
    ok(hr == D3DERR_INVALIDCALL, "GetDevice failed, got %lx, expected %lx (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    count = IDirect3DDevice9_Release(device2);
    ok(count == 2, "Release failed, got %lu, expected 2\n", count);
 
    count = effect->lpVtbl->Release(effect);
    ok(count == 0, "Release failed %lu\n", count);
 
    hr = D3DXCreateEffectPool(NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %lx, expected %lx (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateEffectPool(&pool);
    ok(hr == S_OK, "Got result %lx, expected 0 (S_OK)\n", hr);
 
    count = pool->lpVtbl->Release(pool);
    ok(count == 0, "Release failed %lu\n", count);
 
    hr = D3DXCreateEffectPool(&pool);
    ok(hr == S_OK, "Got result %lx, 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 %lx, expected 0 (D3D_OK)\n", hr);
 
    hr = pool->lpVtbl->QueryInterface(pool, &IID_ID3DXEffectPool, (void **)&pool2);
    ok(hr == D3D_OK, "Got result %lx, 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 %lu, expected 1\n", count);
 
    hr = IDirect3DDevice9_QueryInterface(device, &IID_IDirect3DDevice9, (void **)&device2);
    ok(hr == D3D_OK, "Got result %lx, expected 0 (D3D_OK)\n", hr);
 
    count = IDirect3DDevice9_Release(device2);
    ok(count == 1, "Release failed, got %lu, expected 1\n", count);
 
    hr = D3DXCreateEffect(device, effect_desc, sizeof(effect_desc), NULL, NULL, 0, pool, &effect, NULL);
    ok(hr == D3D_OK, "Got result %lx, expected 0 (D3D_OK)\n", hr);
 
    hr = effect->lpVtbl->GetPool(effect, &pool);
    ok(hr == D3D_OK, "GetPool failed, got %lx, 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 %lu, expected 2\n", count);
 
    count = effect->lpVtbl->Release(effect);
    ok(count == 0, "Release failed %lu\n", count);
 
    count = pool->lpVtbl->Release(pool);
    ok(count == 0, "Release failed %lu\n", count);
}

Referenced by START_TEST().

test_create_effect_compiler()

static void test_create_effect_compiler ( void  )

static

Definition at line 362 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 %lx, expected %lx (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateEffectCompiler(NULL, 0, NULL, NULL, 0, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %lx, expected %lx (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateEffectCompiler(effect_desc, 0, NULL, NULL, 0, &compiler, NULL);
    ok(hr == D3D_OK, "Got result %lx, expected %lx (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 %lu\n", count);
 
    hr = D3DXCreateEffectCompiler(effect_desc, 0, NULL, NULL, 0, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %lx, expected %lx (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateEffectCompiler(NULL, sizeof(effect_desc), NULL, NULL, 0, &compiler, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %lx, expected %lx (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateEffectCompiler(NULL, sizeof(effect_desc), NULL, NULL, 0, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %lx, expected %lx (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateEffectCompiler(effect_desc, sizeof(effect_desc), NULL, NULL, 0, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %lx, expected %lx (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 
    hr = D3DXCreateEffectCompiler(effect_desc, sizeof(effect_desc), NULL, NULL, 0, &compiler, NULL);
    ok(hr == D3D_OK, "Got result %lx, expected %lx (D3D_OK)\n", hr, D3D_OK);
 
    hr = compiler->lpVtbl->QueryInterface(compiler, &IID_ID3DXBaseEffect, (void **)&base);
    ok(hr == E_NOINTERFACE, "QueryInterface failed, got %lx, expected %lx (E_NOINTERFACE)\n", hr, E_NOINTERFACE);
 
    hr = compiler->lpVtbl->QueryInterface(compiler, &IID_ID3DXEffectCompiler, (void **)&compiler2);
    ok(hr == D3D_OK, "QueryInterface failed, got %lx, expected %lx (D3D_OK)\n", hr, D3D_OK);
 
    hr = compiler->lpVtbl->QueryInterface(compiler, &IID_IUnknown, (void **)&unknown);
    ok(hr == D3D_OK, "QueryInterface failed, got %lx, expected %lx (D3D_OK)\n", hr, D3D_OK);
 
    count = unknown->lpVtbl->Release(unknown);
    ok(count == 2, "Release failed, got %lu, expected %u\n", count, 2);
 
    count = compiler2->lpVtbl->Release(compiler2);
    ok(count == 1, "Release failed, got %lu, expected %u\n", count, 1);
 
    count = compiler->lpVtbl->Release(compiler);
    ok(count == 0, "Release failed %lu\n", count);
}

Referenced by START_TEST().

test_create_effect_from_file()

static void test_create_effect_from_file ( void  )

static

Definition at line 8123 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 %#lx.\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 %#lx.\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 %#lx.\n", hr);
    if (messages)
    {
        trace("D3DXCreateEffectFromFileExW messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
        ID3DXBuffer_Release(messages);
    }
 
    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 %#lx.\n", hr);
    if (messages)
    {
        trace("D3DXCreateEffectFromFileExW messages:\n%s", (char *)ID3DXBuffer_GetBufferPointer(messages));
        ID3DXBuffer_Release(messages);
    }
 
    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %lu 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 6603 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 %#lx.\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 %#lx.\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 %#lx.\n", hr);
 
    hr = effect1->lpVtbl->GetValue(effect1, param1, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#lx.\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 3123 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 %#lx.\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 7580 of file effect.c.

{
    D3DXHANDLE parameter, parameter2, technique, technique2, block, annotation;
    IDirect3DDevice9 *device, *device2, *device3;
    IDirect3DBaseTexture9 *texture, *texture2;
    ID3DXEffectStateManager *ret_manager;
    struct test_manager *state_manager;
    IDirect3DVertexShader9 *vs, *vs2;
    ID3DXEffect *effect, *cloned;
    unsigned int passes_count;
    HWND window, window2;
    const char *string;
    ULONG refcount;
    HRESULT hr;
    float f;
 
    static const DWORD effect_code[] =
    {
#if 0
        Texture2D tex;
        float f <float a = 1.0;>;
        string s;
        float skipped : register(c4);
 
        float4 vs0_main(float4 pos : POSITION) : POSITION
        {
            return pos;
        }
 
        vertexshader vs = compile vs_2_0 vs0_main();
 
        technique tech0 <float a = 1.0;>
        {
            pass p
            {
                VertexShader = vs;
            }
        }
 
        float4 vs1_main(float4 pos : POSITION) : POSITION
        {
            return skipped;
        }
 
        technique tech1
        {
            pass p
            {
                VertexShader = compile vs_2_0 vs1_main();
            }
        }
#endif
        0xfeff0901, 0x00000160, 0x00000000, 0x00000007, 0x00000004, 0x0000001c, 0x00000000, 0x00000000,
        0x00000001, 0x00000004, 0x00786574, 0x00000003, 0x00000000, 0x0000006c, 0x00000000, 0x00000000,
        0x00000001, 0x00000001, 0x00000000, 0x3f800000, 0x00000003, 0x00000000, 0x00000064, 0x00000000,
        0x00000000, 0x00000001, 0x00000001, 0x00000002, 0x00000061, 0x00000002, 0x00000066, 0x00000004,
        0x00000004, 0x0000008c, 0x00000000, 0x00000000, 0x00000002, 0x00000002, 0x00000073, 0x00000003,
        0x00000000, 0x000000b4, 0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x00000000, 0x00000008,
        0x70696b73, 0x00646570, 0x00000010, 0x00000004, 0x000000d8, 0x00000000, 0x00000000, 0x00000003,
        0x00000003, 0x00007376, 0x3f800000, 0x00000003, 0x00000000, 0x00000100, 0x00000000, 0x00000000,
        0x00000001, 0x00000001, 0x00000002, 0x00000061, 0x00000004, 0x00000010, 0x00000004, 0x00000000,
        0x00000000, 0x00000000, 0x00000002, 0x00000070, 0x00000006, 0x68636574, 0x00000030, 0x00000005,
        0x00000010, 0x00000004, 0x00000000, 0x00000000, 0x00000000, 0x00000002, 0x00000070, 0x00000006,
        0x68636574, 0x00000031, 0x00000005, 0x00000002, 0x00000005, 0x00000006, 0x00000004, 0x00000018,
        0x00000000, 0x00000000, 0x00000024, 0x00000040, 0x00000000, 0x00000001, 0x00000048, 0x00000044,
        0x00000074, 0x00000088, 0x00000000, 0x00000000, 0x00000094, 0x000000b0, 0x00000000, 0x00000000,
        0x000000c0, 0x000000d4, 0x00000000, 0x00000000, 0x00000128, 0x00000001, 0x00000001, 0x000000e4,
        0x000000e0, 0x00000120, 0x00000000, 0x00000001, 0x00000092, 0x00000000, 0x0000010c, 0x00000108,
        0x00000154, 0x00000000, 0x00000001, 0x0000014c, 0x00000000, 0x00000001, 0x00000092, 0x00000000,
        0x00000138, 0x00000134, 0x00000003, 0x00000002, 0x00000003, 0x00000074, 0xfffe0200, 0x0014fffe,
        0x42415443, 0x0000001c, 0x00000023, 0xfffe0200, 0x00000000, 0x00000000, 0x00000400, 0x0000001c,
        0x325f7376, 0x4d00305f, 0x6f726369, 0x74666f73, 0x29522820, 0x534c4820, 0x6853204c, 0x72656461,
        0x6d6f4320, 0x656c6970, 0x30312072, 0xab00312e, 0x0200001f, 0x80000000, 0x900f0000, 0x02000001,
        0xc00f0000, 0x90e40000, 0x0000ffff, 0x00000002, 0x00000000, 0x00000001, 0x00000000, 0x00000001,
        0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x000000a4, 0xfffe0200, 0x0023fffe, 0x42415443,
        0x0000001c, 0x0000005f, 0xfffe0200, 0x00000001, 0x0000001c, 0x20000400, 0x00000058, 0x00000030,
        0x00040002, 0x00120001, 0x00000038, 0x00000048, 0x70696b73, 0x00646570, 0x00030000, 0x00010001,
        0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x325f7376, 0x4d00305f,
        0x6f726369, 0x74666f73, 0x29522820, 0x534c4820, 0x6853204c, 0x72656461, 0x6d6f4320, 0x656c6970,
        0x30312072, 0xab00312e, 0x02000001, 0xc00f0000, 0xa0000004, 0x0000ffff, 0x00000000, 0x00000000,
        0xffffffff, 0x00000000, 0x00000001, 0x00000003, 0x00007376,
    };
 
    if (!(device = create_device(&window)))
        return;
 
    state_manager = calloc(1, sizeof(*state_manager));
    test_effect_state_manager_init(state_manager, device);
 
    hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, 0, D3DFMT_X8R8G8B8,
            D3DPOOL_DEFAULT, (IDirect3DTexture9 **)&texture, NULL);
    ok(hr == D3D_OK, "Failed to create texture, hr %#lx.\n", hr);
 
    /* D3DXFX_NOT_CLONEABLE */
    hr = D3DXCreateEffect(device, effect_code, sizeof(effect_code),
            NULL, NULL, D3DXFX_NOT_CLONEABLE, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    technique = effect->lpVtbl->GetTechniqueByName(effect, "tech0");
    ok(!!technique, "Expected a technique.\n");
 
    technique2 = effect->lpVtbl->GetCurrentTechnique(effect);
    ok(technique2 == technique, "Got unexpected technique %p.\n", technique2);
 
    hr = effect->lpVtbl->SetTechnique(effect, "tech1");
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->CloneEffect(effect, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
 
    cloned = (void *)0xdeadbeef;
    hr = effect->lpVtbl->CloneEffect(effect, NULL, &cloned);
    ok(hr == E_FAIL, "Got result %#lx.\n", hr);
    ok(cloned == (void *)0xdeadbeef, "Unexpected effect pointer.\n");
 
    hr = effect->lpVtbl->CloneEffect(effect, device, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
 
    cloned = (void *)0xdeadbeef;
    hr = effect->lpVtbl->CloneEffect(effect, device, &cloned);
    ok(hr == E_FAIL, "Got result %#lx.\n", hr);
    ok(cloned == (void *)0xdeadbeef, "Unexpected effect pointer.\n");
 
    effect->lpVtbl->Release(effect);
 
    hr = D3DXCreateEffectEx(device, effect_code, sizeof(effect_code),
            NULL, NULL, "skipped", 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetStateManager(effect, &state_manager->ID3DXEffectStateManager_iface);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetTexture(effect, "tex", texture);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetFloat(effect, "f", 123.0f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetString(effect, "s", "tiny silver hammers");
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetFloat(effect, "f@a", 4.0f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    annotation = effect->lpVtbl->GetAnnotationByName(effect, "tech0", "a");
    ok(!!annotation, "Failed to get annotation.\n");
    hr = effect->lpVtbl->SetFloat(effect, annotation, 4.0f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    parameter = effect->lpVtbl->GetParameterByName(effect, NULL, "tex");
    ok(!!parameter, "Failed to get parameter.\n");
 
    hr = effect->lpVtbl->GetVertexShader(effect, "vs", &vs);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    ok(!effect->lpVtbl->IsParameterUsed(effect, "skipped", "tech1"),
            "Unexpected IsParameterUsed result.\n");
 
    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->CloneEffect(effect, NULL, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
 
    cloned = (void *)0xdeadbeef;
    hr = effect->lpVtbl->CloneEffect(effect, NULL, &cloned);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
    ok(cloned == (void *)0xdeadbeef, "Unexpected effect pointer.\n");
 
    hr = effect->lpVtbl->CloneEffect(effect, device, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->CloneEffect(effect, device, &cloned);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(cloned != effect, "Expected new effect instance.\n");
 
    hr = cloned->lpVtbl->GetStateManager(cloned, &ret_manager);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(!ret_manager, "Unexpected state manager %p.\n", ret_manager);
 
    hr = cloned->lpVtbl->GetTexture(cloned, "tex", &texture2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(texture2 == texture, "Expected the same texture.\n");
    IDirect3DBaseTexture9_Release(texture2);
 
    hr = cloned->lpVtbl->GetVertexShader(cloned, "vs", &vs2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(vs2 == vs, "Expected the same vertex shader.\n");
    IDirect3DVertexShader9_Release(vs2);
 
    ok(!effect->lpVtbl->IsParameterUsed(effect, "skipped", "tech1"),
            "Unexpected IsParameterUsed result.\n");
 
    f = 0.0f;
    hr = cloned->lpVtbl->GetFloat(cloned, "f", &f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(f == 123.0f, "Got float %.8e.\n", f);
 
    hr = cloned->lpVtbl->GetString(cloned, "s", &string);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(!strcmp(string, "tiny silver hammers"), "Got string %s.\n", debugstr_a(string));
 
    f = 0.0f;
    hr = cloned->lpVtbl->GetFloat(cloned, "f@a", &f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(f == 4.0f, "Got float %.8e.\n", f);
 
    annotation = cloned->lpVtbl->GetAnnotationByName(cloned, "tech0", "a");
    ok(!!annotation, "Failed to get annotation.\n");
    f = 0.0f;
    hr = cloned->lpVtbl->GetFloat(cloned, annotation, &f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(f == 4.0f, "Got float %.8e.\n", f);
 
    parameter2 = cloned->lpVtbl->GetParameterByName(cloned, NULL, "tex");
    ok(!!parameter2, "Failed to get parameter.\n");
    ok(parameter2 != parameter, "Parameters should not match.\n");
 
    hr = cloned->lpVtbl->BeginPass(cloned, 0);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
 
    technique = cloned->lpVtbl->GetTechniqueByName(cloned, "tech0");
    ok(!!technique, "Expected a technique.\n");
 
    technique2 = cloned->lpVtbl->GetCurrentTechnique(cloned);
    ok(technique2 == technique, "Got unexpected technique %p.\n", technique2);
 
    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 %#lx.\n", hr);
    ok(cloned != effect, "Expected new effect instance.\n");
 
    hr = cloned->lpVtbl->GetDevice(cloned, &device3);
    ok(hr == S_OK, "Failed to get effect device.\n");
    ok(device3 == device2, "Unexpected device instance.\n");
    IDirect3DDevice9_Release(device3);
 
    hr = cloned->lpVtbl->GetTexture(cloned, "tex", &texture2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(!texture2, "Expected a NULL texture.\n");
 
    hr = cloned->lpVtbl->GetVertexShader(cloned, "vs", &vs2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(vs2 != vs, "Expected a different vertex shader.\n");
    IDirect3DVertexShader9_Release(vs2);
 
    f = 0.0f;
    hr = cloned->lpVtbl->GetFloat(cloned, "f", &f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(f == 123.0f, "Got float %.8e.\n", f);
 
    hr = cloned->lpVtbl->GetString(cloned, "s", &string);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(!strcmp(string, "tiny silver hammers"), "Got string %s.\n", debugstr_a(string));
 
    f = 0.0f;
    hr = cloned->lpVtbl->GetFloat(cloned, "f@a", &f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(f == 4.0f, "Got float %.8e.\n", f);
 
    annotation = cloned->lpVtbl->GetAnnotationByName(cloned, "tech0", "a");
    ok(!!annotation, "Failed to get annotation.\n");
    f = 0.0f;
    hr = cloned->lpVtbl->GetFloat(cloned, annotation, &f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(f == 4.0f, "Got float %.8e.\n", f);
 
    parameter2 = cloned->lpVtbl->GetParameterByName(cloned, NULL, "tex");
    ok(!!parameter2, "Failed to get parameter.\n");
    ok(parameter2 != parameter, "Parameters should not match.\n");
 
    hr = cloned->lpVtbl->BeginPass(cloned, 0);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
 
    technique = cloned->lpVtbl->GetTechniqueByName(cloned, "tech0");
    ok(!!technique, "Expected a technique.\n");
 
    technique2 = cloned->lpVtbl->GetCurrentTechnique(cloned);
    ok(technique2 == technique, "Got unexpected technique %p.\n", technique2);
 
    cloned->lpVtbl->Release(cloned);
 
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    /* Test parameter blocks (we can't do this above since we can't record a
     * parameter block while started). */
 
    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetFloat(effect, "f", 456.0f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->CloneEffect(effect, device, &cloned);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    block = cloned->lpVtbl->EndParameterBlock(cloned);
    ok(!block, "Expected no active parameter block.\n");
 
    cloned->lpVtbl->Release(cloned);
 
    block = effect->lpVtbl->EndParameterBlock(effect);
    ok(!!block, "Expected an active parameter block.\n");
 
    IDirect3DVertexShader9_Release(vs);
    IDirect3DDevice9_Release(device2);
    DestroyWindow(window2);
    effect->lpVtbl->Release(effect);
    refcount = state_manager->ID3DXEffectStateManager_iface.lpVtbl->Release(
            &state_manager->ID3DXEffectStateManager_iface);
    ok(!refcount, "State manager was not properly freed, refcount %lu.\n", refcount);
    IDirect3DBaseTexture9_Release(texture);
    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %lu references left.\n", refcount);
    DestroyWindow(window);
}

Referenced by START_TEST().

test_effect_commitchanges()

static void test_effect_commitchanges ( IDirect3DDevice9 *  device )

static

Definition at line 5533 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};
 
    D3DXEFFECT_DESC desc;
    ID3DXEffect *effect;
    HRESULT hr;
    D3DXHANDLE param;
    unsigned int i, passes_count;
    union
    {
        DWORD dw;
        float f;
    } float_value;
    DWORD 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, "Unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetDesc(effect, &desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", desc.Creator);
    ok(!desc.Functions, "Unexpected value %u.\n", desc.Functions);
    ok(desc.Techniques == 1, "Unexpected value %u.\n", desc.Techniques);
    ok(desc.Parameters == 34, "Unexpected value %u.\n", desc.Parameters);
 
    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, "Unexpected hr %#lx.\n", hr);
 
    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    for (i = 0; i < ARRAY_SIZE(check_op_parameters); ++i)
    {
        unsigned int j;
 
        winetest_push_context("Parameter %s", check_op_parameters[i].param_name);
        for (j = 0; j < 8; ++j)
        {
            winetest_push_context("Light %u", j);
            hr = IDirect3DDevice9_SetLight(device, j, &light_filler);
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
            winetest_pop_context();
        }
        param = effect->lpVtbl->GetParameterByName(effect, NULL, check_op_parameters[i].param_name);
        ok(!!param, "Unexpected parameter %p.\n", param);
        hr = effect->lpVtbl->GetValue(effect, param, &fvect, sizeof(fvect));
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        hr = effect->lpVtbl->SetValue(effect, param, &fvect, sizeof(fvect));
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        hr = effect->lpVtbl->CommitChanges(effect);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        test_effect_preshader_op_results(device, check_op_parameters[i].state_updated,
                check_op_parameters[i].param_name);
        winetest_pop_context();
    }
 
    for (i = 0; i < ARRAY_SIZE(check_vconsts_parameters); ++i)
    {
        winetest_push_context("Float constants, parameter %s", check_vconsts_parameters[i].param_name);
        test_effect_clear_vconsts(device);
        param = effect->lpVtbl->GetParameterByName(effect, NULL, check_vconsts_parameters[i].param_name);
        ok(!!param, "Unexpected parameter %p.\n", param);
        hr = effect->lpVtbl->GetValue(effect, param, buffer, sizeof(buffer));
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        hr = effect->lpVtbl->SetValue(effect, param, buffer, sizeof(buffer));
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        hr = effect->lpVtbl->CommitChanges(effect);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        test_effect_preshader_compare_vconsts(device, check_vconsts_parameters[i].const_updated_mask,
                check_vconsts_parameters[i].param_name);
        winetest_pop_context();
    }
 
    for (i = 0; i < ARRAY_SIZE(check_bconsts_parameters); ++i)
    {
        winetest_push_context("Bool constants, parameter %s", check_bconsts_parameters[i].param_name);
        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 %#lx.\n", hr);
        hr = effect->lpVtbl->SetValue(effect, param, buffer, sizeof(buffer));
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
        hr = effect->lpVtbl->CommitChanges(effect);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
        test_effect_preshader_compare_pbool_consts(device, check_bconsts_parameters[i].const_updated_mask,
                check_bconsts_parameters[i].param_name);
        winetest_pop_context();
    }
 
    test_effect_clear_vconsts(device);
    param = effect->lpVtbl->GetParameterByName(effect, NULL, "g_Selector");
    ok(!!param, "Unexpected parameter %p.\n", param);
    fvect.x = fvect.y = fvect.z = fvect.w = 0.0f;
    hr = effect->lpVtbl->SetVectorArray(effect, param, &fvect, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\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, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\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, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\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, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\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, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\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, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\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, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    test_effect_preshader_compare_vconsts(device, check_vconsts_parameters[7].const_updated_mask,
                check_vconsts_parameters[7].param_name);
 
    float_value.f = 9999.0f;
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGDENSITY, float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSCALE_A, float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSCALE_B, float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\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, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetValue(effect, param, &fvect, sizeof(float) * 3);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_FOGDENSITY, &float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(float_value.f == 0, "Unexpected fog density %.8e.\n", float_value.f);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_FOGSTART, &float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(float_value.f == 4.0f, "Unexpected fog start %.8e.\n", float_value.f);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSCALE_A, &float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(float_value.f == 9999.0f, "Unexpected point scale A %.8e.\n", float_value.f);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSCALE_B, &float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(float_value.f == 9999.0f, "Unexpected point scale B %.8e.\n", float_value.f);
    test_effect_preshader_compare_vconsts(device, check_vconsts_parameters[8].const_updated_mask,
                check_vconsts_parameters[8].param_name);
 
    float_value.f = 9999.0f;
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGDENSITY, float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSCALE_A, float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSCALE_B, float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\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, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetValue(effect, param, &fvect.x, sizeof(float));
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_FOGDENSITY, &float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(float_value.f == 9999.0f, "Unexpected fog density %.8e.\n", float_value.f);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_FOGSTART, &float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(float_value.f == 9999.0f, "Unexpected fog start %.8e.\n", float_value.f);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSCALE_A, &float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(float_value.f == 4.0f, "Unexpected point scale A %.8e.\n", float_value.f);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSCALE_B, &float_value.dw);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(float_value.f == 12.0f, "Unexpected point scale B %.8e.\n", float_value.f);
    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, "Unexpected hr %#lx.\n", hr);
    ok(value == 1, "Unexpected sampler 0 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER1, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    todo_wine
    ok(value == 0, "Unexpected sampler 1 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER2, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == 3, "Unexpected sampler 2 minfilter %lu.\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, "Unexpected hr %#lx.\n", hr);
 
    for (i = 0; i < 3; ++i)
    {
        hr = IDirect3DDevice9_SetSamplerState(device, D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_MINFILTER, 0);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        hr = IDirect3DDevice9_SetSamplerState(device, D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_MAGFILTER, 0);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    }
 
    hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, 0);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, 0);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    test_effect_clear_vconsts(device);
 
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!vshader, "Unexpected vshader %p.\n", vshader);
    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, "Unexpected hr %#lx.\n", hr);
    ok(value == 0, "Unexpected sampler 0 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER1, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == 0, "Unexpected sampler 1 minfilter %lu.\n", value);
 
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER2, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == 1, "Unexpected sampler 2 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER2, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == 0, "Unexpected sampler 2 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == 1, "Unexpected sampler 0 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == 0, "Unexpected sampler 0 minfilter %lu.\n", value);
 
    ivect[3] = 2;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ivect[3] = 1;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!vshader, "Unexpected vshader %p.\n", vshader);
    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, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!!vshader, "Unexpected vshader %p.\n", vshader);
    IDirect3DVertexShader9_Release(vshader);
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 0, &fvect.x, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\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, "Unexpected hr %#lx.\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, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    test_effect_preshader_compare_vconsts(device, NULL, NULL);
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\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 2992 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 %#lx, expected %#lx\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 %#lx, expected %#lx\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 8346 of file effect.c.

{
    D3DPRESENT_PARAMETERS present_parameters = {0};
    D3DXEFFECT_DESC effect_desc;
    IDirect3DDevice9 *device;
    D3DXTECHNIQUE_DESC desc;
    D3DXHANDLE tech, tech2;
    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 %#lx.\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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetDesc(effect, &effect_desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(effect_desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", effect_desc.Creator);
    ok(!effect_desc.Functions, "Unexpected value %u.\n", effect_desc.Functions);
    ok(effect_desc.Techniques == 2, "Unexpected value %u.\n", effect_desc.Techniques);
    ok(!effect_desc.Parameters, "Unexpected value %u.\n", effect_desc.Parameters);
 
    hr = effect->lpVtbl->FindNextValidTechnique(effect, NULL, &tech);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(!strcmp(desc.Name, "tech1"), "Got unexpected technique %s.\n", desc.Name);
 
    tech2 = tech;
    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech2);
    ok(hr == S_FALSE, "Got result %#lx.\n", hr);
    ok(!tech2, "Unexpected technique handle %p.\n", tech2);
    /* Test GetTechniqueDesc() with a NULL handle. */
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech2, &desc);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->FindNextValidTechnique(effect, NULL, &tech);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(!strcmp(desc.Name, "tech1"), "Got unexpected technique %s.\n", desc.Name);
 
    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech2);
    ok(hr == S_FALSE, "Got result %#lx.\n", hr);
    ok(!tech2, "Unexpected technique handle %p.\n", tech2);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech2, &desc);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\n", hr);
 
    tech = (D3DXHANDLE)0xdeadbeef;
    hr = effect->lpVtbl->FindNextValidTechnique(effect, NULL, &tech);
    ok(hr == S_FALSE, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetInt(effect, "i", 0);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->GetTechniqueDesc(effect, tech, &desc);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(!strcmp(desc.Name, "tech1"), "Got unexpected technique %s.\n", desc.Name);
 
    hr = effect->lpVtbl->FindNextValidTechnique(effect, tech, &tech2);
    ok(hr == S_FALSE, "Got result %#lx.\n", hr);
    ok(!tech2, "Unexpected technique handle %p.\n", tech2);
 
    hr = effect->lpVtbl->FindNextValidTechnique(effect, "nope", &tech);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
 
    effect->lpVtbl->Release(effect);
 
    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %lu 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 7088 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 %#lx.\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 %#lx.\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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == E_FAIL, "Got result %#lx.\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 %#lx.\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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\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 %#lx.\n", hr);
 
    pass = effect->lpVtbl->GetPass(effect, "tech0", 1);
    ok(!!pass, "GetPass() failed.\n");
 
    /* Calling GetPassDesc() on a D3DXFX_NOT_CLONEABLE effect is apparently
     * not safe on Windows: the following Release() would crash with a
     * STATUS_ACCESS_VIOLATION exception on the GitLab CI instance. */
    if (0)
    {
    hr = effect->lpVtbl->GetPassDesc(effect, pass, &desc);
    ok(hr == D3D_OK, "Got result %#lx.\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 5306 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;
    D3DXEFFECT_DESC desc;
    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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetDesc(effect, &desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", desc.Creator);
    ok(!desc.Functions, "Unexpected value %u.\n", desc.Functions);
    ok(desc.Techniques == 1, "Unexpected value %u.\n", desc.Techniques);
    ok(desc.Parameters == 34, "Unexpected value %u.\n", desc.Parameters);
 
    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 %#lx.\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 %#lx.\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 7055 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 %#lx.\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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\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 7525 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 %#lx.\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 %#lx.\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 %#lx.\n", hr);
    ok(!desc.pVertexShaderFunction, "Got non NULL vertex function.\n");
 
    hr = effect->lpVtbl->ValidateTechnique(effect, "tech0");
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetInt(effect, "i", 0);
    ok(hr == D3D_OK, "Failed to set parameter, hr %#lx.\n", hr);
    hr = effect->lpVtbl->ValidateTechnique(effect, "tech1");
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetInt(effect, "i", 1);
    ok(hr == D3D_OK, "Failed to set parameter, hr %#lx.\n", hr);
    hr = effect->lpVtbl->ValidateTechnique(effect, "tech1");
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetInt(effect, "i", 2);
    ok(hr == D3D_OK, "Failed to set parameter, hr %#lx.\n", hr);
    hr = effect->lpVtbl->ValidateTechnique(effect, "tech1");
    ok(hr == E_FAIL, "Got result %#lx.\n", hr);
 
    effect->lpVtbl->Release(effect);
 
    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %lu 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 5376 of file effect.c.

{
    D3DXEFFECT_DESC desc;
    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->GetDesc(effect, &desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", desc.Creator);
    ok(!desc.Functions, "Unexpected value %u.\n", desc.Functions);
    ok(desc.Techniques == 1, "Unexpected value %u.\n", desc.Techniques);
    ok(desc.Parameters == 34, "Unexpected value %u.\n", desc.Parameters);
 
    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == E_FAIL, "Got result %#lx.\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 %#lx.\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 %#lx.\n", hr);
    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    test_effect_preshader_compare_shader(device, 1, FALSE);
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ivect[2] = 3;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == E_FAIL, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\n", hr);
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    test_effect_preshader_compare_shader(device, 1, FALSE);
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
 
    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    ivect[2] = -2;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == E_FAIL, "Got result %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(!vshader, "Got non NULL vshader.\n");
 
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    test_effect_preshader_compare_shader(device, 1, FALSE);
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    ivect[2] = -1;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    test_effect_preshader_compare_shader(device, 0, FALSE);
 
    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    ivect[2] = 3;
    hr = effect->lpVtbl->SetValue(effect, param, ivect, sizeof(ivect));
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    test_effect_preshader_compare_shader(device, 1, FALSE);
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#lx.\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 8471 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;
    D3DXPARAMETER_DESC desc;
    ID3DXEffectPool *pool;
    float float_array[4];
    float float_value;
    IDirect3D9 *d3d;
    ULONG refcount;
    HWND window;
    HRESULT hr;
 
    static const DWORD annotation_code[] =
    {
#if 0
        float f <float a = 1.0;>;
 
        float4 vs_main(float4 pos : POSITION) : POSITION
        {
            return pos;
        }
 
        technique tech0
        {
            pass p
            {
                VertexShader = compile vs_2_0 vs_main();
            }
        }
#endif
        0xfeff0901, 0x00000080, 0x00000000, 0x00000003, 0x00000000, 0x0000004c, 0x00000000, 0x00000000,
        0x00000001, 0x00000001, 0x00000000, 0x3f800000, 0x00000003, 0x00000000, 0x00000044, 0x00000000,
        0x00000000, 0x00000001, 0x00000001, 0x00000002, 0x00000061, 0x00000002, 0x00000066, 0x00000001,
        0x00000010, 0x00000004, 0x00000000, 0x00000000, 0x00000000, 0x00000002, 0x00000070, 0x00000006,
        0x68636574, 0x00000030, 0x00000001, 0x00000001, 0x00000002, 0x00000002, 0x00000004, 0x00000020,
        0x00000000, 0x00000001, 0x00000028, 0x00000024, 0x00000074, 0x00000000, 0x00000001, 0x0000006c,
        0x00000000, 0x00000001, 0x00000092, 0x00000000, 0x00000058, 0x00000054, 0x00000000, 0x00000001,
        0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000074, 0xfffe0200, 0x0014fffe,
        0x42415443, 0x0000001c, 0x00000023, 0xfffe0200, 0x00000000, 0x00000000, 0x20000400, 0x0000001c,
        0x325f7376, 0x4d00305f, 0x6f726369, 0x74666f73, 0x29522820, 0x534c4820, 0x6853204c, 0x72656461,
        0x6d6f4320, 0x656c6970, 0x30312072, 0xab00312e, 0x0200001f, 0x80000000, 0x900f0000, 0x02000001,
        0xc00f0000, 0x90e40000, 0x0000ffff,
    };
 
    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 %#lx.\n", hr);
        IDirect3D9_Release(d3d);
        DestroyWindow(window);
        return;
    }
 
    hr = D3DXCreateEffectPool(&pool);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#lx.\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 %lu.\n", refcount);
 
    hr = effect->lpVtbl->ApplyParameterBlock(effect, block);
    ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->DeleteParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "vec3[0]", 1001.0f);
    ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "arr1[0]", 91.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->DeleteParameterBlock(effect2, block);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->DeleteParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->ApplyParameterBlock(effect, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->ApplyParameterBlock(effect, "parameter_block");
    ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#lx.\n", hr);
 
    hr = D3DXCreateTexture(device, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, 0, D3DPOOL_DEFAULT, &texture);
    ok(hr == D3D_OK, "Got result %#lx, expected 0 (D3D_OK).\n", hr);
 
    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
 
    /* Effect parameters are not updated during recording. */
    hr = effect->lpVtbl->SetTexture(effect, "tex1", (IDirect3DBaseTexture9 *)texture);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetTexture(effect, "tex1", (IDirect3DBaseTexture9 **)&tex_test);
    ok(hr == D3D_OK && !tex_test, "Got unexpected hr %#lx, 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 %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "ts1[0].fv", 28.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->GetFloat(effect, "ts1[0].fv", &float_value);
    ok(hr == D3D_OK && float_value == 12.0, "Got unexpected hr %#lx, 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 %#lx.\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 %#lx, 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 %#lx.\n", hr);
    hr = effect->lpVtbl->GetMatrix(effect, "m3x2row", &mat);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    ok(!memcmp(&mat, &effect_orig_mat, sizeof(mat)), "Got unexpected matrix.\n");
    handle = effect->lpVtbl->GetParameterByName(effect, NULL, "m3x2row");
    ok(!!handle, "Failed to find a parameter.\n");
    hr = effect->lpVtbl->GetParameterDesc(effect, handle, &desc);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    ok(desc.Class == D3DXPC_MATRIX_ROWS, "Unexpected class %u.\n", desc.Class);
 
    hr = effect->lpVtbl->SetMatrix(effect, "m3x2column", &test_mat);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->GetMatrix(effect, "m3x2column", &mat);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    ok(!memcmp(&mat, &effect_orig_mat, sizeof(mat)), "Got unexpected matrix.\n");
    handle = effect->lpVtbl->GetParameterByName(effect, NULL, "m3x2column");
    ok(!!handle, "Failed to find a parameter.\n");
    hr = effect->lpVtbl->GetParameterDesc(effect, handle, &desc);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    ok(desc.Class == D3DXPC_MATRIX_ROWS, "Unexpected class %u.\n", desc.Class);
 
    /* 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 %#lx.\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 %lu.\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 %lu.\n", refcount);
 
    hr = effect->lpVtbl->DeleteParameterBlock(effect2, block);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
 
    IDirect3DTexture9_AddRef(texture);
    refcount = IDirect3DTexture9_Release(texture);
    ok(refcount == 2, "Got unexpected refcount %lu.\n", refcount);
 
    hr = effect->lpVtbl->SetFloat(effect, "arr2[0]", 0.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "arr2[1]", 0.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloatArray(effect, "ts1[0].v1", float_array_zero, 3);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "ts1[0].fv", 0.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloatArray(effect, "ts1[0].v2", float_array_zero, 4);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    memset(&mat, 0, sizeof(mat));
    hr = effect->lpVtbl->SetMatrix(effect, "m3x2row", &mat);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetMatrix(effect, "m3x2column", &mat);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->ApplyParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    IDirect3DTexture9_AddRef(texture);
    refcount = IDirect3DTexture9_Release(texture);
    ok(refcount == 3, "Got unexpected refcount %lu.\n", refcount);
 
    hr = effect->lpVtbl->GetFloat(effect, "arr2[0]", &float_value);
    ok(hr == D3D_OK && float_value == 92.0f, "Got unexpected hr %#lx, 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 %#lx, 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 %#lx, 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 %#lx.\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 %#lx.\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 %#lx, 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 %#lx, 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 %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "arr2[1]", 0.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloatArray(effect, "ts1[0].v1", float_array_zero, 3);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "ts1[0].fv", 0.0f);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloatArray(effect, "ts1[0].v2", float_array_zero, 4);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    memset(&mat, 0, sizeof(mat));
    hr = effect->lpVtbl->SetMatrix(effect, "m3x2row", &effect_orig_mat);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->SetMatrix(effect, "m3x2column", &effect_orig_mat);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->ApplyParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetFloat(effect, "arr2[0]", &float_value);
    ok(hr == D3D_OK && float_value == 0.0f, "Got unexpected hr %#lx, 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 %#lx, 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 %#lx, 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 %#lx.\n", hr);
    ok(!memcmp(&mat, &effect_orig_mat, sizeof(mat)), "Got unexpected matrix.\n");
    hr = effect->lpVtbl->GetMatrix(effect, "m3x2column", &mat);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    ok(!memcmp(&mat, &effect_orig_mat, sizeof(mat)), "Got unexpected matrix.\n");
 
    hr = effect->lpVtbl->GetFloat(effect, "ts1[0].fv", &float_value);
    ok(hr == D3D_OK && float_value == 0.0f, "Got unexpected hr %#lx, 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] == 0.0f
            && !memcmp(float_array + 1, float_array_zero, 3 * sizeof(*float_array)),
            "Got unexpected hr %#lx, ts1[0].v2 (%g, %g, %g, %g).\n", hr,
            float_array[0], float_array[1], float_array[2], float_array[3]);
 
    block2 = effect->lpVtbl->EndParameterBlock(effect);
    ok(!!block2, "Got unexpected block %p.\n", block2);
 
    hr = effect->lpVtbl->ApplyParameterBlock(effect, block2);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetFloat(effect, "arr2[0]", &float_value);
    ok(hr == D3D_OK && float_value == 92.0f, "Got unexpected hr %#lx, 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 %#lx, 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 %#lx, 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 %#lx.\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 %#lx.\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 %#lx, 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 %#lx, ts1[0].v2 (%g, %g, %g, %g).\n", hr,
            float_array[0], float_array[1], float_array[2], float_array[3]);
 
    hr = effect->lpVtbl->DeleteParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->DeleteParameterBlock(effect, block2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetTexture(effect, "tex1", NULL);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    refcount = IDirect3DTexture9_Release(texture);
    ok(!refcount, "Got unexpected refcount %lu.\n", refcount);
 
    refcount = effect->lpVtbl->Release(effect);
    ok(!refcount, "Got unexpected refcount %lu.\n", refcount);
 
    refcount = effect2->lpVtbl->Release(effect2);
    ok(!refcount, "Got unexpected refcount %lu.\n", refcount);
 
    refcount = pool->lpVtbl->Release(pool);
    ok(!refcount, "Got unexpected refcount %lu.\n", refcount);
 
    hr = D3DXCreateEffect(device, test_effect_parameter_value_blob_float, sizeof(test_effect_parameter_value_blob_float),
            NULL, NULL, 0, NULL, &effect, NULL);
    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    mat_arr[0] = mat_arr[1] = test_mat;
    hr = effect->lpVtbl->SetMatrixArray(effect, "f33_2", mat_arr, 2);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    block = effect->lpVtbl->EndParameterBlock(effect);
    ok(!!block, "Got unexpected block %p.\n", block);
 
    memset(mat_arr, 0, sizeof(mat_arr));
    hr = effect->lpVtbl->SetMatrixArray(effect, "f33_2", mat_arr, 2);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->ApplyParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetMatrixArray(effect, "f33_2", mat_arr, 2);
    ok(hr == D3D_OK, "Got unexpected hr %#lx.\n", hr);
    ok(!memcmp(&mat_arr[0], &test_mat, sizeof(test_mat))
            && !memcmp(&mat_arr[1], &test_mat, sizeof(test_mat)), "Got unexpected matrix array.\n");
 
    refcount = effect->lpVtbl->Release(effect);
    ok(!refcount, "Got unexpected refcount %lu.\n", refcount);
 
    hr = D3DXCreateEffect(device, annotation_code, sizeof(annotation_code),
            NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetFloat(effect, "f@a", &float_value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(float_value == 1.0f, "Got float %.8e.\n", float_value);
    hr = effect->lpVtbl->SetFloat(effect, "f@a", 2.0f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->GetFloat(effect, "f@a", &float_value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(float_value == 2.0f, "Got float %.8e.\n", float_value);
 
    hr = effect->lpVtbl->BeginParameterBlock(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "f@a", 3.0f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->GetFloat(effect, "f@a", &float_value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(float_value == 2.0f, "Got float %.8e.\n", float_value);
    block = effect->lpVtbl->EndParameterBlock(effect);
    ok(!!block, "Got unexpected block %p.\n", block);
    hr = effect->lpVtbl->ApplyParameterBlock(effect, block);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->GetFloat(effect, "f@a", &float_value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(float_value == 3.0f, "Got float %.8e.\n", float_value);
 
    refcount = effect->lpVtbl->Release(effect);
    ok(!refcount, "Got unexpected refcount %lu.\n", refcount);
 
    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %lu references left.\n", refcount);
    IDirect3D9_Release(d3d);
    DestroyWindow(window);
}

Referenced by START_TEST().

test_effect_parameter_value()

static void test_effect_parameter_value ( IDirect3DDevice9 *  device )

static

Definition at line 1952 of file effect.c.

{
    unsigned int effect_count = ARRAY_SIZE(test_effect_parameter_value_data), i;
 
    for (i = 0; i < effect_count; ++i)
    {
        const struct test_effect_parameter_value_result *res = test_effect_parameter_value_data[i].res;
        UINT res_count = test_effect_parameter_value_data[i].res_count;
        UINT blob_size = test_effect_parameter_value_data[i].blob_size;
        const DWORD *blob = test_effect_parameter_value_data[i].blob;
        D3DXEFFECT_DESC edesc;
        ID3DXEffect *effect;
        unsigned int k;
        ULONG refcount;
        HRESULT hr;
 
        winetest_push_context("Test %u", i);
        hr = D3DXCreateEffect(device, blob, blob_size, NULL, NULL, 0, NULL, &effect, NULL);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        hr = effect->lpVtbl->GetDesc(effect, &edesc);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        ok(edesc.Parameters == res_count, "Unexpected Parameters %u, expected %u.\n",
                edesc.Parameters, res_count);
 
        for (k = 0; k < res_count; ++k)
        {
            const char *name = res[k].name;
            D3DXHANDLE parameter;
            D3DXPARAMETER_DESC pdesc;
            BOOL bvalue = TRUE;
            INT ivalue = 42;
            FLOAT fvalue = 2.71828f;
            DWORD input_value[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
            DWORD expected_value[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
            UINT l, n, m, count;
            const D3DXMATRIX *matrix_pointer_array[sizeof(input_value)/(sizeof(D3DXMATRIX))];
 
            winetest_push_context("Parameter %s", name);
            parameter = effect->lpVtbl->GetParameterByName(effect, NULL, name);
            ok(!!parameter, "Unexpected parameter %p.\n", parameter);
 
            hr = effect->lpVtbl->GetParameterDesc(effect, parameter, &pdesc);
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            ok(!strcmp(pdesc.Name, name), "Unexpected Name %s, expected %s.\n", debugstr_a(pdesc.Name), debugstr_a(name));
            ok(!pdesc.Semantic, "Unexpected Semantic %s.\n", debugstr_a(pdesc.Semantic));
 
            ok(res[k].class == pdesc.Class, "Unexpected Class %#x, expected %#x.\n",
                    pdesc.Class, res[k].class);
            ok(res[k].type == pdesc.Type, "Unexpected Type %#x, expected %#x.\n", pdesc.Type, res[k].type);
            ok(res[k].rows == pdesc.Rows, "Unexpected Rows %u, expected %u.\n",
                    pdesc.Rows, res[k].rows);
            ok(res[k].columns == pdesc.Columns, "Unexpected Columns %u, expected %u.\n",
                    pdesc.Columns, res[k].columns);
            ok(res[k].elements == pdesc.Elements, "Unexpected Elements %u, expected %u.\n",
                    pdesc.Elements, res[k].elements);
            ok(!pdesc.Annotations, "Unexpected Annotations %u.\n", pdesc.Annotations);
            ok(!pdesc.StructMembers, "Unexpected StructMembers %u.\n", pdesc.StructMembers);
            ok(!pdesc.Flags, "Unexpected Flags %lu.\n", pdesc.Flags);
            ok(res[k].bytes == pdesc.Bytes, "Unexpected Bytes %u, expected %u.\n",
                    pdesc.Bytes, res[k].bytes);
 
            test_effect_parameter_values(&res[k], effect, res[k].value.dword, parameter);
            test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
            test_effect_parameter_values(&res[k], effect, res[k].value.dword, parameter);
 
            /*
             * check invalid calls
             * These will crash:
             * effect->lpVtbl->SetBoolArray(effect, parameter, NULL, res_desc->Bytes / sizeof(BOOL));
             * effect->lpVtbl->SetIntArray(effect, parameter, NULL, res_desc->Bytes / sizeof(INT));
             * effect->lpVtbl->SetFloatArray(effect, parameter, NULL, res_desc->Bytes / sizeof(FLOAT));
             * effect->lpVtbl->SetVector(effect, parameter, NULL);
             * effect->lpVtbl->SetVectorArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
             * effect->lpVtbl->SetMatrix(effect, parameter, NULL);
             * effect->lpVtbl->GetMatrix(effect, parameter, NULL);
             * effect->lpVtbl->SetMatrixArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
             * effect->lpVtbl->SetMatrixPointerArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
             * effect->lpVtbl->SetMatrixTranspose(effect, parameter, NULL);
             * effect->lpVtbl->SetMatrixTransposeArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
             * effect->lpVtbl->SetMatrixTransposePointerArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
             * effect->lpVtbl->GetValue(effect, parameter, NULL, res_desc->Bytes);
             * effect->lpVtbl->SetValue(effect, parameter, NULL, res_desc->Bytes);
             */
            hr = effect->lpVtbl->SetBool(effect, NULL, bvalue);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetBool(effect, NULL, &bvalue);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetBool(effect, parameter, NULL);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetBoolArray(effect, NULL, (BOOL *)input_value, res[k].bytes / sizeof(BOOL));
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetBoolArray(effect, NULL, (BOOL *)input_value, res[k].bytes / sizeof(BOOL));
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetBoolArray(effect, parameter, NULL, res[k].bytes / sizeof(BOOL));
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetInt(effect, NULL, ivalue);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetInt(effect, NULL, &ivalue);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetInt(effect, parameter, NULL);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetIntArray(effect, NULL, (INT *)input_value, res[k].bytes / sizeof(INT));
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetIntArray(effect, NULL, (INT *)input_value, res[k].bytes / sizeof(INT));
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetIntArray(effect, parameter, NULL, res[k].bytes / sizeof(INT));
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetFloat(effect, NULL, fvalue);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetFloat(effect, NULL, &fvalue);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetFloat(effect, parameter, NULL);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetFloatArray(effect, NULL, (FLOAT *)input_value, res[k].bytes / sizeof(FLOAT));
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetFloatArray(effect, NULL, (FLOAT *)input_value, res[k].bytes / sizeof(FLOAT));
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetFloatArray(effect, parameter, NULL, res[k].bytes / sizeof(FLOAT));
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetVector(effect, NULL, (D3DXVECTOR4 *)input_value);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetVector(effect, NULL, (D3DXVECTOR4 *)input_value);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetVector(effect, parameter, NULL);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetVectorArray(effect, NULL, (D3DXVECTOR4 *)input_value, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetVectorArray(effect, NULL, (D3DXVECTOR4 *)input_value, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetVectorArray(effect, parameter, NULL, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetMatrix(effect, NULL, (D3DXMATRIX *)input_value);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrix(effect, NULL, (D3DXMATRIX *)input_value);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetMatrixArray(effect, NULL, (D3DXMATRIX *)input_value, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixArray(effect, NULL, (D3DXMATRIX *)input_value, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixArray(effect, parameter, NULL, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetMatrixPointerArray(effect, NULL, matrix_pointer_array, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetMatrixPointerArray(effect, NULL, matrix_pointer_array, 0);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixPointerArray(effect, NULL, NULL, 0);
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixPointerArray(effect, NULL, NULL, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixPointerArray(effect, parameter, NULL, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetMatrixTranspose(effect, NULL, (D3DXMATRIX *)input_value);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixTranspose(effect, NULL, (D3DXMATRIX *)input_value);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixTranspose(effect, parameter, NULL);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetMatrixTransposeArray(effect, NULL, (D3DXMATRIX *)input_value, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixTransposeArray(effect, NULL, (D3DXMATRIX *)input_value, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixTransposeArray(effect, parameter, NULL, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetMatrixTransposePointerArray(effect, NULL, matrix_pointer_array, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetMatrixTransposePointerArray(effect, NULL, matrix_pointer_array, 0);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, NULL, NULL, 0);
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, NULL, NULL, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, parameter, NULL, res[k].elements ? res[k].elements : 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetValue(effect, NULL, input_value, res[k].bytes);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->SetValue(effect, parameter, input_value, res[k].bytes - 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetValue(effect, NULL, input_value, res[k].bytes);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            hr = effect->lpVtbl->GetValue(effect, parameter, input_value, res[k].bytes - 1);
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            test_effect_parameter_values(&res[k], effect, res[k].value.dword, parameter);
 
            /* SetBool */
            bvalue = 5;
            memcpy(expected_value, res[k].value.dword, res[k].bytes);
            hr = effect->lpVtbl->SetBool(effect, parameter, bvalue);
            if (!res[k].elements && res[k].rows == 1 && res[k].columns == 1)
            {
                bvalue = TRUE;
                set_number(expected_value, res[k].type, &bvalue, D3DXPT_BOOL);
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
            }
            else
            {
                ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
            }
            test_effect_parameter_values(&res[k], effect, expected_value, parameter);
            test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
 
            /* SetBoolArray */
            *input_value = 1;
            for (l = 1; l < res[k].bytes / sizeof(*input_value); ++l)
            {
                *(input_value + l) = *(input_value + l - 1) + 1;
            }
            memcpy(expected_value, res[k].value.dword, res[k].bytes);
            hr = effect->lpVtbl->SetBoolArray(effect, parameter, (BOOL *)input_value, res[k].bytes / sizeof(*input_value));
            if (res[k].class == D3DXPC_SCALAR
                    || res[k].class == D3DXPC_VECTOR
                    || res[k].class == D3DXPC_MATRIX_ROWS)
            {
                for (l = 0; l < res[k].bytes / sizeof(*input_value); ++l)
                {
                    set_number(expected_value + l, res[k].type, input_value + l, D3DXPT_BOOL);
                }
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
            }
            else
            {
                ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
            }
            test_effect_parameter_values(&res[k], effect, expected_value, parameter);
            test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
 
            /* SetInt */
            ivalue = 0x1fbf02ff;
            memcpy(expected_value, res[k].value.dword, res[k].bytes);
            hr = effect->lpVtbl->SetInt(effect, parameter, ivalue);
            if (!res[k].elements && res[k].rows == 1 && res[k].columns == 1)
            {
                set_number(expected_value, res[k].type, &ivalue, D3DXPT_INT);
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
            }
            else if (!res[k].elements && res[k].type == D3DXPT_FLOAT &&
                     ((res[k].class == D3DXPC_VECTOR && res[k].columns != 2) ||
                     (res[k].class == D3DXPC_MATRIX_ROWS && res[k].rows != 2 && res[k].columns == 1)))
            {
                FLOAT tmp = ((ivalue & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE;
                set_number(expected_value, res[k].type, &tmp, D3DXPT_FLOAT);
                tmp = ((ivalue & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE;
                set_number(expected_value + 1, res[k].type, &tmp, D3DXPT_FLOAT);
                tmp = (ivalue & 0xff) * INT_FLOAT_MULTI_INVERSE;
                set_number(expected_value + 2, res[k].type, &tmp, D3DXPT_FLOAT);
                tmp = ((ivalue & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
                set_number(expected_value + 3, res[k].type, &tmp, D3DXPT_FLOAT);
 
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
            }
            else
            {
                ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
            }
            test_effect_parameter_values(&res[k], effect, expected_value, parameter);
            test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
 
            /* SetIntArray */
            *input_value = 123456;
            for (l = 1; l < res[k].bytes / sizeof(*input_value); ++l)
            {
                *(input_value + l) = *(input_value + l - 1) + 23;
            }
            memcpy(expected_value, res[k].value.dword, res[k].bytes);
            hr = effect->lpVtbl->SetIntArray(effect, parameter, (INT *)input_value, res[k].bytes / sizeof(*input_value));
            if (res[k].class == D3DXPC_SCALAR
                    || res[k].class == D3DXPC_VECTOR
                    || res[k].class == D3DXPC_MATRIX_ROWS)
            {
                for (l = 0; l < res[k].bytes / sizeof(*input_value); ++l)
                {
                    set_number(expected_value + l, res[k].type, input_value + l, D3DXPT_INT);
                }
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
            }
            else
            {
                ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
            }
            test_effect_parameter_values(&res[k], effect, expected_value, parameter);
            test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
 
            /* SetFloat */
            fvalue = 1.33;
            memcpy(expected_value, res[k].value.dword, res[k].bytes);
            hr = effect->lpVtbl->SetFloat(effect, parameter, fvalue);
            if (!res[k].elements && res[k].rows == 1 && res[k].columns == 1)
            {
                set_number(expected_value, res[k].type, &fvalue, D3DXPT_FLOAT);
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
            }
            else
            {
                ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
            }
            test_effect_parameter_values(&res[k], effect, expected_value, parameter);
            test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
 
            /* SetFloatArray */
            fvalue = 1.33;
            for (l = 0; l < res[k].bytes / sizeof(fvalue); ++l)
            {
                *(input_value + l) = *(DWORD *)&fvalue;
                fvalue += 1.12;
            }
            memcpy(expected_value, res[k].value.dword, res[k].bytes);
            hr = effect->lpVtbl->SetFloatArray(effect, parameter, (FLOAT *)input_value, res[k].bytes / sizeof(*input_value));
            if (res[k].class == D3DXPC_SCALAR
                    || res[k].class == D3DXPC_VECTOR
                    || res[k].class == D3DXPC_MATRIX_ROWS)
            {
                for (l = 0; l < res[k].bytes / sizeof(*input_value); ++l)
                {
                    set_number(expected_value + l, res[k].type, input_value + l, D3DXPT_FLOAT);
                }
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
            }
            else
            {
                ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
            }
            test_effect_parameter_values(&res[k], effect, expected_value, parameter);
            test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
 
            /* SetVector */
            fvalue = -1.33;
            for (l = 0; l < 4; ++l)
            {
                *(input_value + l) = *(DWORD *)&fvalue;
                fvalue += 1.12;
            }
            memcpy(expected_value, res[k].value.dword, res[k].bytes);
            hr = effect->lpVtbl->SetVector(effect, parameter, (D3DXVECTOR4 *)input_value);
            if (!res[k].elements &&
                    (res[k].class == D3DXPC_SCALAR
                    || res[k].class == D3DXPC_VECTOR))
            {
                /* only values between 0 and INT_FLOAT_MULTI are valid */
                if (res[k].type == D3DXPT_INT && res[k].bytes == 4)
                {
                    *expected_value = (DWORD)(max(min(*(FLOAT *)(input_value + 2), 1.0f), 0.0f) * INT_FLOAT_MULTI);
                    *expected_value += ((DWORD)(max(min(*(FLOAT *)(input_value + 1), 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 8;
                    *expected_value += ((DWORD)(max(min(*(FLOAT *)input_value, 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 16;
                    *expected_value += ((DWORD)(max(min(*(FLOAT *)(input_value + 3), 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 24;
                }
                else
                {
                    for (l = 0; l < 4; ++l)
                    {
                        set_number(expected_value + l, res[k].type, input_value + l, D3DXPT_FLOAT);
                    }
                }
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
            }
            else
            {
                ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
            }
            test_effect_parameter_values(&res[k], effect, expected_value, parameter);
            test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
 
            /* SetVectorArray */
            for (count = 0; count < res[k].elements + 1; ++count)
            {
                fvalue = 1.33;
                for (l = 0; l < count * 4; ++l)
                {
                    *(input_value + l) = *(DWORD *)&fvalue;
                    fvalue += 1.12;
                }
                memcpy(expected_value, res[k].value.dword, res[k].bytes);
                hr = effect->lpVtbl->SetVectorArray(effect, parameter, (D3DXVECTOR4 *)input_value, count);
                if (res[k].elements && res[k].class == D3DXPC_VECTOR && count <= res[k].elements)
                {
                    for (m = 0; m < count; ++m)
                    {
                        for (l = 0; l < res[k].columns; ++l)
                        {
                            set_number(expected_value + m * res[k].columns + l, res[k].type, input_value + m * 4 + l, D3DXPT_FLOAT);
                        }
                    }
                    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
                }
                else
                {
                    ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
                }
                test_effect_parameter_values(&res[k], effect, expected_value, parameter);
                test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
            }
 
            /* SetMatrix */
            fvalue = 1.33;
            for (l = 0; l < 16; ++l)
            {
                *(input_value + l) = *(DWORD *)&fvalue;
                fvalue += 1.12;
            }
            memcpy(expected_value, res[k].value.dword, res[k].bytes);
            hr = effect->lpVtbl->SetMatrix(effect, parameter, (D3DXMATRIX *)input_value);
            if (!res[k].elements && res[k].class == D3DXPC_MATRIX_ROWS)
            {
                for (l = 0; l < 4; ++l)
                {
                    for (m = 0; m < 4; ++m)
                    {
                        if (m < res[k].rows && l < res[k].columns)
                            set_number(expected_value + l + m * res[k].columns, res[k].type,
                                    input_value + l + m * 4, D3DXPT_FLOAT);
                    }
 
                }
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
            }
            else
            {
                ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
            }
            test_effect_parameter_values(&res[k], effect, expected_value, parameter);
            test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
 
            /* SetMatrixArray */
            for (count = 0; count < res[k].elements + 1; ++count)
            {
                fvalue = 1.33;
                for (l = 0; l < count * 16; ++l)
                {
                    *(input_value + l) = *(DWORD *)&fvalue;
                    fvalue += 1.12;
                }
                memcpy(expected_value, res[k].value.dword, res[k].bytes);
                hr = effect->lpVtbl->SetMatrixArray(effect, parameter, (D3DXMATRIX *)input_value, count);
                if (res[k].class == D3DXPC_MATRIX_ROWS && count <= res[k].elements)
                {
                    for (n = 0; n < count; ++n)
                    {
                        for (l = 0; l < 4; ++l)
                        {
                            for (m = 0; m < 4; ++m)
                            {
                                if (m < res[k].rows && l < res[k].columns)
                                    set_number(expected_value + l + m * res[k].columns + n * res[k].columns * res[k].rows,
                                            res[k].type, input_value + l + m * 4 + n * 16, D3DXPT_FLOAT);
                            }
 
                        }
                    }
                    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
                }
                else
                {
                    ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
                }
                test_effect_parameter_values(&res[k], effect, expected_value, parameter);
                test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
            }
 
            /* SetMatrixPointerArray */
            for (count = 0; count < res[k].elements + 1; ++count)
            {
                fvalue = 1.33;
                for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
                {
                    *(input_value + l) = *(DWORD *)&fvalue;
                    fvalue += 1.12;
                }
                memcpy(expected_value, res[k].value.dword, res[k].bytes);
                for (l = 0; l < count; ++l)
                {
                    matrix_pointer_array[l] = (D3DXMATRIX *)&input_value[l * sizeof(**matrix_pointer_array) / sizeof(FLOAT)];
                }
                hr = effect->lpVtbl->SetMatrixPointerArray(effect, parameter, matrix_pointer_array, count);
                if (res[k].class == D3DXPC_MATRIX_ROWS && res[k].elements >= count)
                {
                    for (n = 0; n < count; ++n)
                    {
                        for (l = 0; l < 4; ++l)
                        {
                            for (m = 0; m < 4; ++m)
                            {
                                if (m < res[k].rows && l < res[k].columns)
                                    set_number(expected_value + l + m * res[k].columns + n * res[k].columns * res[k].rows,
                                            res[k].type, input_value + l + m * 4 + n * 16, D3DXPT_FLOAT);
                            }
 
                        }
                    }
                    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
                }
                else
                {
                    ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
                }
                test_effect_parameter_values(&res[k], effect, expected_value, parameter);
                test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
            }
 
            /* SetMatrixTranspose */
            fvalue = 1.33;
            for (l = 0; l < 16; ++l)
            {
                *(input_value + l) = *(DWORD *)&fvalue;
                fvalue += 1.12;
            }
            memcpy(expected_value, res[k].value.dword, res[k].bytes);
            hr = effect->lpVtbl->SetMatrixTranspose(effect, parameter, (D3DXMATRIX *)input_value);
            if (!res[k].elements && res[k].class == D3DXPC_MATRIX_ROWS)
            {
                for (l = 0; l < 4; ++l)
                {
                    for (m = 0; m < 4; ++m)
                    {
                        if (m < res[k].rows && l < res[k].columns)
                            set_number(expected_value + l + m * res[k].columns, res[k].type,
                                    input_value + l * 4 + m, D3DXPT_FLOAT);
                    }
 
                }
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
            }
            else
            {
                ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
            }
            test_effect_parameter_values(&res[k], effect, expected_value, parameter);
            test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
 
            /* SetMatrixTransposeArray */
            for (count = 0; count < res[k].elements + 1; ++count)
            {
                fvalue = 1.33;
                for (l = 0; l < count * 16; ++l)
                {
                    *(input_value + l) = *(DWORD *)&fvalue;
                    fvalue += 1.12;
                }
                memcpy(expected_value, res[k].value.dword, res[k].bytes);
                hr = effect->lpVtbl->SetMatrixTransposeArray(effect, parameter, (D3DXMATRIX *)input_value, count);
                if (res[k].class == D3DXPC_MATRIX_ROWS && count <= res[k].elements)
                {
                    for (n = 0; n < count; ++n)
                    {
                        for (l = 0; l < 4; ++l)
                        {
                            for (m = 0; m < 4; ++m)
                            {
                                if (m < res[k].rows && l < res[k].columns)
                                    set_number(expected_value + l + m * res[k].columns + n * res[k].columns * res[k].rows,
                                            res[k].type, input_value + l * 4 + m + n * 16, D3DXPT_FLOAT);
                            }
 
                        }
                    }
                    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
                }
                else
                {
                    ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
                }
                test_effect_parameter_values(&res[k], effect, expected_value, parameter);
                test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
            }
 
            /* SetMatrixTransposePointerArray */
            for (count = 0; count < res[k].elements + 1; ++count)
            {
                fvalue = 1.33;
                for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
                {
                    *(input_value + l) = *(DWORD *)&fvalue;
                    fvalue += 1.12;
                }
                memcpy(expected_value, res[k].value.dword, res[k].bytes);
                for (l = 0; l < count; ++l)
                {
                    matrix_pointer_array[l] = (D3DXMATRIX *)&input_value[l * sizeof(**matrix_pointer_array) / sizeof(FLOAT)];
                }
                hr = effect->lpVtbl->SetMatrixTransposePointerArray(effect, parameter, matrix_pointer_array, count);
                if (res[k].class == D3DXPC_MATRIX_ROWS && res[k].elements >= count)
                {
                    for (n = 0; n < count; ++n)
                    {
                        for (l = 0; l < 4; ++l)
                        {
                            for (m = 0; m < 4; ++m)
                            {
                                if (m < res[k].rows && l < res[k].columns)
                                    set_number(expected_value + l + m * res[k].columns + n * res[k].columns * res[k].rows,
                                            res[k].type, input_value + l * 4 + m + n * 16, D3DXPT_FLOAT);
                            }
 
                        }
                    }
                    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
                }
                else
                {
                    ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
                }
                test_effect_parameter_values(&res[k], effect, expected_value, parameter);
                test_effect_parameter_value_reset(&res[k], effect, res[k].value.dword, parameter);
            }
            winetest_pop_context();
        }
 
        refcount = effect->lpVtbl->Release(effect);
        ok(!refcount, "Unexpected refcount %lu.\n", refcount);
        winetest_pop_context();
    }
}

Referenced by START_TEST().

test_effect_parameter_value_GetBool()

static void test_effect_parameter_value_GetBool ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1235 of file effect.c.

{
    BOOL bvalue = 0xabababab;
    HRESULT hr;
 
    hr = effect->lpVtbl->GetBool(effect, parameter, &bvalue);
    if (!res->elements && res->rows == 1 && res->columns == 1)
    {
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        ok(bvalue == get_bool(res_value), "Unexpected value %#x, expected %#x.\n",
                bvalue, get_bool(res_value));
    }
    else
    {
        ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
        ok(bvalue == 0xabababab, "Unexpected value %#x.\n", bvalue);
    }
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetBoolArray()

static void test_effect_parameter_value_GetBoolArray ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1255 of file effect.c.

{
    BOOL bavalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
    unsigned int l, err = 0;
    HRESULT hr;
 
    memset(bavalue, 0xab, sizeof(bavalue));
    hr = effect->lpVtbl->GetBoolArray(effect, parameter, bavalue, res->bytes / sizeof(*bavalue));
    if (res->class == D3DXPC_SCALAR
            || res->class == D3DXPC_VECTOR
            || res->class == D3DXPC_MATRIX_ROWS)
    {
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < res->bytes / sizeof(*bavalue); ++l)
        {
            if (bavalue[l] != get_bool(&res_value[l]))
                ++err;
        }
 
        for (l = res->bytes / sizeof(*bavalue); l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
        {
            if (bavalue[l] != 0xabababab)
                ++err;
        }
    }
    else
    {
        ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
            if (bavalue[l] != 0xabababab)
                ++err;
    }
    ok(!err, "Unexpected value in %u elements.\n", err);
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetFloat()

static void test_effect_parameter_value_GetFloat ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1365 of file effect.c.

{
    DWORD cmp = 0xabababab;
    float fvalue;
    HRESULT hr;
 
    fvalue = *(float *)&cmp;
    hr = effect->lpVtbl->GetFloat(effect, parameter, &fvalue);
    if (!res->elements && res->columns == 1 && res->rows == 1)
    {
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        ok(compare_float(fvalue, get_float(res->type, res_value), 512), "Unexpected value %.8e, expected %.8e.\n",
                fvalue, get_float(res->type, res_value));
    }
    else
    {
        ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
        ok(fvalue == *(float *)&cmp, "Unexpected value %.8e, expected %.8e.\n", fvalue, *(float *)&cmp);
    }
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetFloatArray()

static void test_effect_parameter_value_GetFloatArray ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1387 of file effect.c.

{
    float favalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
    unsigned int l, err = 0;
    DWORD cmp = 0xabababab;
    HRESULT hr;
 
    memset(favalue, 0xab, sizeof(favalue));
    hr = effect->lpVtbl->GetFloatArray(effect, parameter, favalue, res->bytes / sizeof(*favalue));
    if (res->class == D3DXPC_SCALAR
            || res->class == D3DXPC_VECTOR
            || res->class == D3DXPC_MATRIX_ROWS)
    {
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < res->bytes / sizeof(*favalue); ++l)
        {
            if (!compare_float(favalue[l], get_float(res->type, &res_value[l]), 512))
                ++err;
        }
 
        for (l = res->bytes / sizeof(*favalue); l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
        {
            if (favalue[l] != *(float *)&cmp)
                ++err;
        }
    }
    else
    {
        ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (favalue[l] != *(FLOAT *)&cmp) ++err;
    }
    ok(!err, "Unexpected value in %u elements.\n", err);
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetInt()

static void test_effect_parameter_value_GetInt ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1293 of file effect.c.

{
    int ivalue = 0xabababab;
    HRESULT hr;
 
    hr = effect->lpVtbl->GetInt(effect, parameter, &ivalue);
    if (!res->elements && res->columns == 1 && res->rows == 1)
    {
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        ok(ivalue == get_int(res->type, res_value), "Unexpected value %d, expected %d.\n",
                ivalue, get_int(res->type, res_value));
    }
    else if (!res->elements && res->type == D3DXPT_FLOAT &&
             ((res->class == D3DXPC_VECTOR && res->columns != 2) ||
             (res->class == D3DXPC_MATRIX_ROWS && res->rows != 2 && res->columns == 1)))
    {
        int tmp;
 
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        tmp = (int)(min(max(0.0f, *((float *)res_value + 2)), 1.0f) * INT_FLOAT_MULTI);
        tmp |= ((int)(min(max(0.0f, *((float *)res_value + 1)), 1.0f) * INT_FLOAT_MULTI)) << 8;
        tmp |= ((int)(min(max(0.0f, *((float *)res_value + 0)), 1.0f) * INT_FLOAT_MULTI)) << 16;
        if (res->columns * res->rows > 3)
        {
            tmp |= ((int)(min(max(0.0f, *((float *)res_value + 3)), 1.0f) * INT_FLOAT_MULTI)) << 24;
        }
 
        ok(ivalue == tmp, "Unexpected value %x, expected %x.\n", ivalue, tmp);
    }
    else
    {
        ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
        ok(ivalue == 0xabababab, "Unexpected value %d.\n", ivalue);
    }
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetIntArray()

static void test_effect_parameter_value_GetIntArray ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1331 of file effect.c.

{
    int iavalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
    unsigned int l, err = 0;
    HRESULT hr;
 
    memset(iavalue, 0xab, sizeof(iavalue));
    hr = effect->lpVtbl->GetIntArray(effect, parameter, iavalue, res->bytes / sizeof(*iavalue));
    if (res->class == D3DXPC_SCALAR
            || res->class == D3DXPC_VECTOR
            || res->class == D3DXPC_MATRIX_ROWS)
    {
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < res->bytes / sizeof(*iavalue); ++l)
        {
            if (iavalue[l] != get_int(res->type, &res_value[l])) ++err;
        }
 
        for (l = res->bytes / sizeof(*iavalue); l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
        {
            if (iavalue[l] != 0xabababab) ++err;
        }
    }
    else
    {
        ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (iavalue[l] != 0xabababab) ++err;
    }
    ok(!err, "Unexpected value in %u elements.\n", err);
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetMatrix()

static void test_effect_parameter_value_GetMatrix ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1529 of file effect.c.

{
    unsigned int l, k, err = 0;
    float fvalue[16];
    union
    {
        DWORD d;
        float f;
    } cmp;
    HRESULT hr;
 
    cmp.d = 0xabababab;
    memset(fvalue, 0xab, sizeof(fvalue));
    hr = effect->lpVtbl->GetMatrix(effect, parameter, (D3DXMATRIX *)&fvalue);
    if (!res->elements && res->class == D3DXPC_MATRIX_ROWS)
    {
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        for (k = 0; k < 4; ++k)
        {
            for (l = 0; l < 4; ++l)
            {
                if (k < res->columns && l < res->rows)
                {
                    if (!compare_float(fvalue[l * 4 + k], get_float(res->type,
                            &res_value[l * res->columns + k]), 512))
                        ++err;
                }
                else if (fvalue[l * 4 + k] != 0.0f) ++err;
            }
        }
    }
    else
    {
        ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < ARRAY_SIZE(fvalue); ++l)
            if (fvalue[l] != cmp.f)
                ++err;
    }
    ok(!err, "Unexpected value in %u elements.\n", err);
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetMatrixArray()

static void test_effect_parameter_value_GetMatrixArray ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1573 of file effect.c.

{
    float fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
    unsigned int l, k, m, count, err = 0;
    DWORD cmp = 0xabababab;
    HRESULT hr;
 
    for (count = 0; count <= res->elements + 1; ++count)
    {
        winetest_push_context("Count %u", count);
        memset(fvalue, 0xab, sizeof(fvalue));
        hr = effect->lpVtbl->GetMatrixArray(effect, parameter, (D3DXMATRIX *)&fvalue, count);
        if (!count)
        {
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
                if (fvalue[l] != *(float *)&cmp)
                    ++err;
        }
        else if (count <= res->elements && res->class == D3DXPC_MATRIX_ROWS)
        {
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            for (m = 0; m < count; ++m)
            {
                for (k = 0; k < 4; ++k)
                {
                    for (l = 0; l < 4; ++l)
                    {
                        if (k < res->columns && l < res->rows)
                        {
                            if (!compare_float(fvalue[m * 16 + l * 4 + k], get_float(res->type,
                                                    &res_value[m * res->columns * res->rows
                                                            + l * res->columns + k]), 512))
                                ++err;
                        }
                        else if (fvalue[m * 16 + l * 4 + k] != 0.0f)
                            ++err;
                    }
                }
            }
 
            for (l = count * 16; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
                if (fvalue[l] != *(float *)&cmp)
                    ++err;
        }
        else
        {
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
                if (fvalue[l] != *(float *)&cmp)
                    ++err;
        }
        ok(!err, "Unexpected value in %u elements.\n", err);
        winetest_pop_context();
    }
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetMatrixPointerArray()

static void test_effect_parameter_value_GetMatrixPointerArray ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1634 of file effect.c.

{
    union
    {
        float f[sizeof(D3DXMATRIX) / sizeof(float)];
        D3DXMATRIX m;
    } fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE * sizeof(float) / sizeof(D3DXMATRIX)];
    D3DXMATRIX *matrix_pointer_array[ARRAY_SIZE(fvalue)];
    unsigned int l, k, m, count, err = 0;
    union
    {
        DWORD d;
        float f;
    } cmp = {0xabababab};
    HRESULT hr;
 
    for (count = 0; count <= res->elements + 1; ++count)
    {
        winetest_push_context("Count %u", count);
        memset(fvalue, 0xab, sizeof(fvalue));
        for (l = 0; l < count; ++l)
        {
            matrix_pointer_array[l] = &fvalue[l].m;
        }
        hr = effect->lpVtbl->GetMatrixPointerArray(effect, parameter, matrix_pointer_array, count);
        if (!count)
        {
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            for (m = 0; m < ARRAY_SIZE(fvalue); ++m)
                for (l = 0; l < ARRAY_SIZE(fvalue[l].f); ++l)
                    if (fvalue[m].f[l] != cmp.f)
                        ++err;
        }
        else if (count <= res->elements && res->class == D3DXPC_MATRIX_ROWS)
        {
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            for (m = 0; m < count; ++m)
            {
                for (k = 0; k < 4; ++k)
                {
                    for (l = 0; l < 4; ++l)
                    {
                        if (k < res->columns && l < res->rows)
                        {
                            if (!compare_float(fvalue[m].m.m[l][k], get_float(res->type,
                                    &res_value[m * res->columns * res->rows + l * res->columns + k]), 512))
                                ++err;
                        }
                        else if (fvalue[m].m.m[l][k] != 0.0f)
                            ++err;
                    }
                }
            }
 
            for (m = count; m < ARRAY_SIZE(fvalue); ++m)
                for (l = 0; l < ARRAY_SIZE(fvalue[m].f); ++l)
                    if (fvalue[m].f[l] != cmp.f)
                        ++err;
        }
        else
        {
            for (m = 0; m < ARRAY_SIZE(fvalue); ++m)
                for (l = 0; l < ARRAY_SIZE(fvalue[m].f); ++l)
                    if (fvalue[m].f[l] != cmp.f)
                        ++err;
 
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
        }
        ok(!err, "Unexpected value in %u elements.\n", err);
        winetest_pop_context();
    }
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetMatrixTranspose()

static void test_effect_parameter_value_GetMatrixTranspose ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1710 of file effect.c.

{
    unsigned int l, k, err = 0;
    HRESULT hr;
    union
    {
        DWORD d;
        float f;
    } cmp;
    float fvalue[16];
 
    cmp.d = 0xabababab;
    memset(fvalue, 0xab, sizeof(fvalue));
    hr = effect->lpVtbl->GetMatrixTranspose(effect, parameter, (D3DXMATRIX *)&fvalue);
    if (!res->elements && res->class == D3DXPC_MATRIX_ROWS)
    {
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        for (k = 0; k < 4; ++k)
        {
            for (l = 0; l < 4; ++l)
            {
                if (k < res->columns && l < res->rows)
                {
                    if (!compare_float(fvalue[l + k * 4], get_float(res->type,
                            &res_value[l * res->columns + k]), 512))
                        ++err;
                }
                else if (fvalue[l + k * 4] != 0.0f) ++err;
            }
        }
    }
    else if (!res->elements && (res->class == D3DXPC_VECTOR || res->class == D3DXPC_SCALAR))
    {
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        for (k = 0; k < 4; ++k)
        {
            for (l = 0; l < 4; ++l)
            {
                if (k < res->columns && l < res->rows)
                {
                    if (!compare_float(fvalue[l * 4 + k], get_float(res->type,
                            &res_value[l * res->columns + k]), 512))
                        ++err;
                }
                else if (fvalue[l * 4 + k] != 0.0f) ++err;
            }
        }
    }
    else
    {
        ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < ARRAY_SIZE(fvalue); ++l)
            if (fvalue[l] != cmp.f)
                ++err;
    }
    ok(!err, "Unexpected value in %u elements.\n", err);
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetMatrixTransposeArray()

static void test_effect_parameter_value_GetMatrixTransposeArray ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1772 of file effect.c.

{
    float fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
    unsigned int l, k, m, count, err = 0;
    DWORD cmp = 0xabababab;
    HRESULT hr;
 
    for (count = 0; count <= res->elements + 1; ++count)
    {
        winetest_push_context("Count %u", count);
        memset(fvalue, 0xab, sizeof(fvalue));
        hr = effect->lpVtbl->GetMatrixTransposeArray(effect, parameter, (D3DXMATRIX *)&fvalue, count);
        if (!count)
        {
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
        }
        else if (count <= res->elements && res->class == D3DXPC_MATRIX_ROWS)
        {
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            for (m = 0; m < count; ++m)
            {
                for (k = 0; k < 4; ++k)
                {
                    for (l = 0; l < 4; ++l)
                    {
                        if (k < res->columns && l < res->rows)
                        {
                            if (!compare_float(fvalue[m * 16 + l + k * 4], get_float(res->type,
                                    &res_value[m * res->columns * res->rows + l * res->columns + k]), 512))
                                ++err;
                        }
                        else if (fvalue[m * 16 + l + k * 4] != 0.0f) ++err;
                    }
                }
            }
 
            for (l = count * 16; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
        }
        else
        {
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
        }
        ok(!err, "Unexpected value in %u elements.\n", err);
        winetest_pop_context();
    }
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetMatrixTransposePointerArray()

static void test_effect_parameter_value_GetMatrixTransposePointerArray ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1825 of file effect.c.

{
    union
    {
        float f[sizeof(D3DXMATRIX) / sizeof(float)];
        D3DXMATRIX m;
    } fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE * sizeof(float) / sizeof(D3DXMATRIX)];
    D3DXMATRIX *matrix_pointer_array[sizeof(fvalue)];
    unsigned int l, k, m, count, err = 0;
    union
    {
        DWORD d;
        float f;
    } cmp = {0xabababab};
    HRESULT hr;
 
    for (count = 0; count <= res->elements + 1; ++count)
    {
        winetest_push_context("Count %u", count);
        memset(fvalue, 0xab, sizeof(fvalue));
        for (l = 0; l < count; ++l)
        {
            matrix_pointer_array[l] = &fvalue[l].m;
        }
        hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, parameter, matrix_pointer_array, count);
        if (!count)
        {
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            for (m = 0; m < ARRAY_SIZE(fvalue); ++m)
                for (l = 0; l < ARRAY_SIZE(fvalue[m].f); ++l)
                    if (fvalue[m].f[l] != cmp.f)
                        ++err;
        }
        else if (count <= res->elements && res->class == D3DXPC_MATRIX_ROWS)
        {
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            for (m = 0; m < count; ++m)
            {
                for (k = 0; k < 4; ++k)
                {
                    for (l = 0; l < 4; ++l)
                    {
                        if (k < res->columns && l < res->rows)
                        {
                            if (!compare_float(fvalue[m].m.m[k][l], get_float(res->type,
                                    &res_value[m * res->columns * res->rows + l * res->columns + k]), 512))
                                ++err;
                        }
                        else if (fvalue[m].m.m[k][l] != 0.0f)
                            ++err;
                    }
                }
            }
 
            for (m = count; m < ARRAY_SIZE(fvalue); ++m)
                for (l = 0; l < ARRAY_SIZE(fvalue[m].f); ++l)
                    if (fvalue[m].f[l] != cmp.f)
                        ++err;
        }
        else
        {
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            for (m = 0; m < ARRAY_SIZE(fvalue); ++m)
                for (l = 0; l < ARRAY_SIZE(fvalue[m].f); ++l)
                    if (fvalue[m].f[l] != cmp.f)
                        ++err;
        }
        ok(!err, "Unexpected value in %u elements.\n", err);
        winetest_pop_context();
    }
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetValue()

static void test_effect_parameter_value_GetValue ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1173 of file effect.c.

{
    DWORD value[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
    unsigned int l;
    HRESULT hr;
 
    memset(value, 0xab, sizeof(value));
    hr = effect->lpVtbl->GetValue(effect, parameter, value, res->bytes);
    if (res->class == D3DXPC_SCALAR
            || res->class == D3DXPC_VECTOR
            || res->class == D3DXPC_MATRIX_ROWS)
    {
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < res->bytes / sizeof(*value); ++l)
        {
            ok(value[l] == res_value[l], "Unexpected value[%u] %#lx, expected %#lx.\n",
                    l, value[l], res_value[l]);
        }
 
        for (l = res->bytes / sizeof(*value); l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
        {
            ok(value[l] == 0xabababab, "Unexpected value[%u] %#lx.\n", l, value[l]);
        }
    }
    else if (res->class == D3DXPC_OBJECT)
    {
        switch (res->type)
        {
            case D3DXPT_PIXELSHADER:
            case D3DXPT_VERTEXSHADER:
            case D3DXPT_TEXTURE2D:
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
                for (l = 0; l < (res->elements ? res->elements : 1); ++l)
                {
                    IUnknown *unk = *((IUnknown **)value + l);
                    if (unk) IUnknown_Release(unk);
                }
                break;
 
            case D3DXPT_STRING:
                ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
                break;
 
            default:
                ok(0, "Type is %u, this should not happen!\n", res->type);
                break;
        }
    }
    else
    {
        ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
        {
            ok(value[l] == 0xabababab, "Unexpected value[%u] %#lx.\n", l, value[l]);
        }
    }
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetVector()

static void test_effect_parameter_value_GetVector ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1424 of file effect.c.

{
    unsigned int l, err = 0;
    DWORD cmp = 0xabababab;
    float fvalue[4];
    HRESULT hr;
 
    memset(fvalue, 0xab, sizeof(fvalue));
    hr = effect->lpVtbl->GetVector(effect, parameter, (D3DXVECTOR4 *)&fvalue);
    if (!res->elements &&
            (res->class == D3DXPC_SCALAR || res->class == D3DXPC_VECTOR) &&
            res->type == D3DXPT_INT && res->bytes == 4)
    {
        DWORD tmp;
 
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        tmp = (DWORD)(*(fvalue + 2) * INT_FLOAT_MULTI);
        tmp += ((DWORD)(*(fvalue + 1) * INT_FLOAT_MULTI)) << 8;
        tmp += ((DWORD)(*fvalue * INT_FLOAT_MULTI)) << 16;
        tmp += ((DWORD)(*(fvalue + 3) * INT_FLOAT_MULTI)) << 24;
 
        if (*res_value != tmp)
            ++err;
    }
    else if (!res->elements && (res->class == D3DXPC_SCALAR || res->class == D3DXPC_VECTOR))
    {
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < res->columns; ++l)
            if (!compare_float(fvalue[l], get_float(res->type, &res_value[l]), 512))
                ++err;
 
        for (l = res->columns; l < 4; ++l)
            if (fvalue[l] != 0.0f)
                ++err;
    }
    else
    {
        ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
        for (l = 0; l < 4; ++l)
            if (fvalue[l] != *(float *)&cmp)
                ++err;
    }
    ok(!err, "Unexpected value in %u elements.\n", err);
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_GetVectorArray()

static void test_effect_parameter_value_GetVectorArray ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1473 of file effect.c.

{
    float fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
    unsigned int l, k, element, err = 0;
    DWORD cmp = 0xabababab;
    HRESULT hr;
 
    for (element = 0; element <= res->elements + 1; ++element)
    {
        winetest_push_context("Element %u", element);
        memset(fvalue, 0xab, sizeof(fvalue));
        hr = effect->lpVtbl->GetVectorArray(effect, parameter, (D3DXVECTOR4 *)&fvalue, element);
        if (!element)
        {
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
                if (fvalue[l] != *(float *)&cmp)
                    ++err;
        }
        else if (element <= res->elements && res->class == D3DXPC_VECTOR)
        {
            ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
            for (k = 0; k < element; ++k)
            {
                for (l = 0; l < res->columns; ++l)
                {
                    if (!compare_float(fvalue[l + k * 4], get_float(res->type,
                            &res_value[l + k * res->columns]), 512))
                        ++err;
                }
 
                for (l = res->columns; l < 4; ++l)
                    if (fvalue[l + k * 4] != 0.0f)
                        ++err;
            }
 
            for (l = element * 4; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
                if (fvalue[l] != *(float *)&cmp)
                    ++err;
        }
        else
        {
            ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
            for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
                if (fvalue[l] != *(float *)&cmp)
                    ++err;
        }
        ok(!err, "Unexpected value in %u elements.\n", err);
        winetest_pop_context();
    }
}

Referenced by test_effect_parameter_values().

test_effect_parameter_value_reset()

static void test_effect_parameter_value_reset ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1922 of file effect.c.

{
    HRESULT hr;
 
    if (res->class == D3DXPC_SCALAR
            || res->class == D3DXPC_VECTOR
            || res->class == D3DXPC_MATRIX_ROWS)
    {
        hr = effect->lpVtbl->SetValue(effect, parameter, res_value, res->bytes);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    }
    else
    {
        /* nothing to do */
        switch (res->type)
        {
            case D3DXPT_PIXELSHADER:
            case D3DXPT_VERTEXSHADER:
            case D3DXPT_TEXTURE2D:
            case D3DXPT_STRING:
                break;
 
            default:
                ok(0, "Type is %u, this should not happen!\n", res->type);
                break;
        }
    }
}

Referenced by test_effect_parameter_value().

test_effect_parameter_values()

static void test_effect_parameter_values ( const struct test_effect_parameter_value_result *  res, ID3DXEffect *  effect, const DWORD *  res_value, D3DXHANDLE  parameter  )

static

Definition at line 1902 of file effect.c.

{
    test_effect_parameter_value_GetValue(res, effect, res_value, parameter);
    test_effect_parameter_value_GetBool(res, effect, res_value, parameter);
    test_effect_parameter_value_GetBoolArray(res, effect, res_value, parameter);
    test_effect_parameter_value_GetInt(res, effect, res_value, parameter);
    test_effect_parameter_value_GetIntArray(res, effect, res_value, parameter);
    test_effect_parameter_value_GetFloat(res, effect, res_value, parameter);
    test_effect_parameter_value_GetFloatArray(res, effect, res_value, parameter);
    test_effect_parameter_value_GetVector(res, effect, res_value, parameter);
    test_effect_parameter_value_GetVectorArray(res, effect, res_value, parameter);
    test_effect_parameter_value_GetMatrix(res, effect, res_value, parameter);
    test_effect_parameter_value_GetMatrixArray(res, effect, res_value, parameter);
    test_effect_parameter_value_GetMatrixPointerArray(res, effect, res_value, parameter);
    test_effect_parameter_value_GetMatrixTranspose(res, effect, res_value, parameter);
    test_effect_parameter_value_GetMatrixTransposeArray(res, effect, res_value, parameter);
    test_effect_parameter_value_GetMatrixTransposePointerArray(res, effect, res_value, parameter);
}

Referenced by test_effect_parameter_value().

test_effect_preshader()

static void test_effect_preshader ( IDirect3DDevice9 *  device )

static

Definition at line 4702 of file effect.c.

{
    static const D3DXVECTOR4 test_effect_preshader_fvect_p[] =
    {
        {11.0f, 21.0f,  0.0f, 0.0f},
        {12.0f, 22.0f,  0.0f, 0.0f},
        {13.0f, 23.0f,  0.0f, 0.0f},
        {11.0f, 12.0f,  0.0f, 0.0f},
        {21.0f, 22.0f,  0.0f, 0.0f},
        {31.0f, 32.0f,  0.0f, 0.0f},
        {11.0f, 12.0f,  0.0f, 0.0f},
        {21.0f, 22.0f,  0.0f, 0.0f},
        {11.0f, 21.0f,  0.0f, 0.0f},
        {12.0f, 22.0f,  0.0f, 0.0f},
        {11.0f, 12.0f, 13.0f, 0.0f},
        {21.0f, 22.0f, 23.0f, 0.0f},
        {11.0f, 21.0f, 31.0f, 0.0f},
        {12.0f, 22.0f, 32.0f, 0.0f}
    };
    static const int test_effect_preshader_iconsts[][4] =
    {
        {4, 3, 2, 1}
    };
    static const D3DXVECTOR4 fvect1 = {28.0f, 29.0f, 30.0f, 31.0f};
    static const D3DXVECTOR4 fvect2 = {0.0f, 0.0f, 1.0f, 0.0f};
    static const int ivect_empty[4] = {-1, -1, -1, -1};
    HRESULT hr;
    ID3DXEffect *effect;
    D3DXHANDLE par;
    unsigned int npasses;
    DWORD value;
    D3DXVECTOR4 fdata[ARRAY_SIZE(test_effect_preshader_fvect_p)];
    int idata[ARRAY_SIZE(test_effect_preshader_iconsts)][4];
    IDirect3DVertexShader9 *vshader;
    D3DXEFFECT_DESC desc;
    unsigned int i;
    D3DCAPS9 caps;
 
    hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
    ok(SUCCEEDED(hr), "Failed to get device caps, hr %#lx.\n", hr);
    if (caps.VertexShaderVersion < D3DVS_VERSION(3, 0)
            || caps.PixelShaderVersion < D3DPS_VERSION(3, 0))
    {
        skip("Test requires VS >= 3 and PS >= 3, skipping.\n");
        return;
    }
 
    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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetDesc(effect, &desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", desc.Creator);
    ok(!desc.Functions, "Unexpected value %u.\n", desc.Functions);
    ok(desc.Techniques == 1, "Unexpected value %u.\n", desc.Techniques);
    ok(desc.Parameters == 34, "Unexpected value %u.\n", desc.Parameters);
 
    test_effect_clear_vconsts(device);
 
    for (i = 0; i < 224; ++i)
    {
        hr = IDirect3DDevice9_SetPixelShaderConstantF(device, i, &fvect_filler.x, 1);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    }
 
    test_effect_preshader_clear_pbool_consts(device);
 
    for (i = 0; i < 16; ++i)
    {
        hr = IDirect3DDevice9_SetPixelShaderConstantI(device, i, ivect_empty, 1);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    }
 
    hr = effect->lpVtbl->Begin(effect, &npasses, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    par = effect->lpVtbl->GetParameterByName(effect, NULL, "g_Pos2");
    ok(par != NULL, "GetParameterByName failed.\n");
 
    hr = effect->lpVtbl->SetVector(effect, par, &fvect1);
    ok(hr == D3D_OK, "SetVector failed, hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
 
    test_effect_preshader_compare_vconsts(device, NULL, NULL);
 
    hr = IDirect3DDevice9_GetPixelShaderConstantF(device, 0, &fdata[0].x,
            ARRAY_SIZE(test_effect_preshader_fvect_p));
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(!memcmp(fdata, test_effect_preshader_fvect_p, sizeof(test_effect_preshader_fvect_p)),
            "Pixel shader float constants do not match.\n");
    for (i = ARRAY_SIZE(test_effect_preshader_fvect_p); i < 224; ++i)
    {
        hr = IDirect3DDevice9_GetPixelShaderConstantF(device, i, &fdata[0].x, 1);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
        ok(!memcmp(fdata, &fvect_filler, sizeof(fvect_filler)),
                "Pixel shader float constants do not match.\n");
    }
    hr = IDirect3DDevice9_GetPixelShaderConstantI(device, 0, idata[0],
            ARRAY_SIZE(test_effect_preshader_iconsts));
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(!memcmp(idata, test_effect_preshader_iconsts, sizeof(test_effect_preshader_iconsts)),
            "Pixel shader integer constants do not match.\n");
    for (i = ARRAY_SIZE(test_effect_preshader_iconsts); i < 16; ++i)
    {
        hr = IDirect3DDevice9_GetPixelShaderConstantI(device, i, idata[0], 1);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
        ok(!memcmp(idata[0], ivect_empty, sizeof(ivect_empty)),
                "Pixel shader integer constants do not match.\n");
    }
 
    test_effect_preshader_compare_pbool_consts(device, NULL, NULL);
 
    test_effect_preshader_op_results(device, NULL, NULL);
 
    hr = IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(value == 3, "Unexpected sampler 0 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine ok(value == 3, "Unexpected sampler 0 magfilter %lu.\n", value);
 
    hr = IDirect3DDevice9_GetSamplerState(device, 1, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(value == 1, "Unexpected sampler 1 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, 1, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine
    ok(value == 1, "Unexpected sampler 1 magfilter %lu.\n", value);
 
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER0, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(value == 1, "Unexpected vertex sampler 0 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER0, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine
    ok(value == 1, "Unexpected vertex sampler 0 magfilter %lu.\n", value);
 
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER1, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine
    ok(value == 0, "Unexpected vertex sampler 1 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER1, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine
    ok(value == 0, "Unexpected vertex sampler 1 magfilter %lu.\n", value);
 
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER2, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(value == 3, "Unexpected vertex sampler 2 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER2, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine ok(value == 3, "Unexpected vertex sampler 2 magfilter %lu.\n", value);
 
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_FOGDENSITY, &value);
    ok(hr == D3D_OK, "Got result %#lx.\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 %#lx.\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 %#lx.\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 %#lx.\n", hr);
    ok(*(float *)&value == 12.0f, "Unexpected point scale B %g.\n", *(float *)&value);
 
    hr = effect->lpVtbl->EndPass(effect);
 
    par = effect->lpVtbl->GetParameterByName(effect, NULL, "g_iVect");
    ok(par != NULL, "GetParameterByName failed.\n");
    hr = effect->lpVtbl->SetVector(effect, par, &fvect2);
    ok(hr == D3D_OK, "SetVector failed, hr %#lx.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    test_effect_preshader_compare_shader(device, 1, FALSE);
 
    hr = IDirect3DDevice9_SetVertexShader(device, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetVector(effect, par, &fvect1);
    ok(hr == D3D_OK, "SetVector failed, hr %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(!vshader, "Incorrect shader selected.\n");
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->Begin(effect, &npasses, D3DXFX_DONOTSAVESTATE);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(value == 3, "Unexpected sampler 0 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, 0, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine ok(value == 3, "Unexpected sampler 0 magfilter %lu.\n", value);
 
    hr = IDirect3DDevice9_GetSamplerState(device, 1, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(value == 1, "Unexpected sampler 1 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, 1, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine
    ok(value == 1, "Unexpected sampler 1 magfilter %lu.\n", value);
 
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER0, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(value == 1, "Unexpected vertex sampler 0 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER0, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine
    ok(value == 1, "Unexpected vertex sampler 0 magfilter %lu.\n", value);
 
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER1, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(value == 2, "Unexpected vertex sampler 1 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER1, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine
    ok(value == 2, "Unexpected vertex sampler 1 magfilter %lu.\n", value);
 
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER2, D3DSAMP_MINFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(value == 3, "Unexpected vertex sampler 2 minfilter %lu.\n", value);
    hr = IDirect3DDevice9_GetSamplerState(device, D3DVERTEXTEXTURESAMPLER2, D3DSAMP_MAGFILTER, &value);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine
    ok(value == 3, "Unexpected vertex sampler 2 magfilter %lu.\n", value);
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    effect->lpVtbl->Release(effect);
}

Referenced by START_TEST().

test_effect_preshader_clear_pbool_consts()

static void test_effect_preshader_clear_pbool_consts ( IDirect3DDevice9 *  device )

static

Definition at line 4638 of file effect.c.

{
    BOOL bval;
    unsigned int i;
    HRESULT hr;
 
    for (i = 0; i < 16; ++i)
    {
        bval = i < ARRAY_SIZE(test_effect_preshader_bconsts) ? !test_effect_preshader_bconsts[i] : FALSE;
        hr = IDirect3DDevice9_SetPixelShaderConstantB(device, i, &bval, 1);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    }
}

Referenced by test_effect_commitchanges(), and test_effect_preshader().

test_effect_preshader_compare_pbool_consts_()

static void test_effect_preshader_compare_pbool_consts_ ( unsigned int  line, IDirect3DDevice9 *  device, const unsigned int *  const_updated_mask, const char *  updated_param  )

static

Definition at line 4654 of file effect.c.

{
    unsigned int i;
    BOOL bdata[16];
    HRESULT hr;
 
    hr = IDirect3DDevice9_GetPixelShaderConstantB(device, 0, bdata, ARRAY_SIZE(bdata));
    ok_(__FILE__, line)(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    if (!const_updated_mask)
    {
        for (i = 0; i < ARRAY_SIZE(test_effect_preshader_bconsts); ++i)
        {
            /* The negation on both sides is actually needed, sometimes you
             * get 0xffffffff instead of 1 on native. */
            ok_(__FILE__, line)(!bdata[i] == !test_effect_preshader_bconsts[i],
                    "Pixel shader boolean constants do not match, expected %#x, got %#x, i %u.\n",
                    test_effect_preshader_bconsts[i], bdata[i], i);
        }
    }
    else
    {
        for (i = 0; i < ARRAY_SIZE(test_effect_preshader_bconsts); ++i)
        {
            if (const_updated_mask[i / TEST_EFFECT_BITMASK_BLOCK_SIZE]
                    & (1u << (i % TEST_EFFECT_BITMASK_BLOCK_SIZE)))
            {
                /* The negation on both sides is actually needed, sometimes
                 * you get 0xffffffff instead of 1 on native. */
                ok_(__FILE__, line)(!bdata[i] == !test_effect_preshader_bconsts[i],
                        "Pixel shader boolean constants do not match, expected %#x, got %#x, i %u, parameter %s.\n",
                        test_effect_preshader_bconsts[i], bdata[i], i, updated_param);
            }
            else
            {
                ok_(__FILE__, line)(bdata[i] == !test_effect_preshader_bconsts[i],
                        "Pixel shader boolean constants updated unexpectedly, parameter %s.\n", updated_param);
            }
        }
    }
 
    for (; i < 16; ++i)
    {
        ok_(__FILE__, line)(!bdata[i], "Got result %#lx, boolean register value %u.\n", hr, bdata[i]);
    }
}

test_effect_preshader_compare_shader_()

static void test_effect_preshader_compare_shader_ ( unsigned int  line, IDirect3DDevice9 *  device, int  expected_shader_index, BOOL  todo  )

static

Definition at line 4431 of file effect.c.

{
    IDirect3DVertexShader9 *vshader;
    void *byte_code;
    unsigned int byte_code_size;
    HRESULT hr;
 
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok_(__FILE__, line)(hr == D3D_OK, "IDirect3DDevice9_GetVertexShader result %#lx.\n", hr);
 
    todo_wine_if(todo)
    ok_(__FILE__, line)(!!vshader, "Got NULL vshader.\n");
    if (!vshader)
        return;
 
    hr = IDirect3DVertexShader9_GetFunction(vshader, NULL, &byte_code_size);
    ok_(__FILE__, line)(hr == D3D_OK, "IDirect3DVertexShader9_GetFunction %#lx.\n", hr);
    ok_(__FILE__, line)(byte_code_size > 1, "Got unexpected byte code size %u.\n", byte_code_size);
 
    byte_code = calloc(1, byte_code_size);
    hr = IDirect3DVertexShader9_GetFunction(vshader, byte_code, &byte_code_size);
    ok_(__FILE__, line)(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    test_effect_preshader_compare_shader_bytecode_(line, byte_code,
            byte_code_size, expected_shader_index, todo);
 
    free(byte_code);
    IDirect3DVertexShader9_Release(vshader);
 }

test_effect_preshader_compare_shader_bytecode_()

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

Definition at line 4404 of file effect.c.

{
    unsigned int i = 0;
 
    todo_wine_if(todo)
    ok_(__FILE__, line)(!!bytecode, "NULL shader bytecode.\n");
 
    if (!bytecode)
        return;
 
    while (bytecode[i++] != 0x0000ffff)
        ;
 
    if (!bytecode_size)
        bytecode_size = i * sizeof(*bytecode);
    else
        ok(i * sizeof(*bytecode) == bytecode_size, "Unexpected byte code size %u.\n", bytecode_size);
 
    todo_wine_if(todo)
    ok_(__FILE__, line)(!memcmp(bytecode, &test_effect_preshader_effect_blob[TEST_EFFECT_PRESHADER_VSHADER_POS
            + expected_shader_index * TEST_EFFECT_PRESHADER_VSHADER_LEN], bytecode_size),
            "Incorrect shader selected.\n");
}

Referenced by test_effect_preshader_compare_shader_().

test_effect_preshader_compare_vconsts_()

static void test_effect_preshader_compare_vconsts_ ( unsigned int  line, IDirect3DDevice9 *  device, const unsigned int *  const_updated_mask, const char *  updated_param  )

static

Definition at line 4586 of file effect.c.

{
    HRESULT hr;
    unsigned int i;
    D3DXVECTOR4 fdata[ARRAY_SIZE(test_effect_preshader_fvect_v)];
 
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 0, &fdata[0].x,
            ARRAY_SIZE(test_effect_preshader_fvect_v));
    ok_(__FILE__, line)(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    if (!const_updated_mask)
    {
        ok_(__FILE__, line)(!memcmp(fdata, test_effect_preshader_fvect_v, sizeof(test_effect_preshader_fvect_v)),
                "Vertex shader float constants do not match.\n");
    }
    else
    {
        for (i = 0; i < ARRAY_SIZE(test_effect_preshader_fvect_v); ++i)
        {
            if (const_updated_mask[i / TEST_EFFECT_BITMASK_BLOCK_SIZE]
                    & (1u << (i % TEST_EFFECT_BITMASK_BLOCK_SIZE)))
            {
                ok_(__FILE__, line)(!memcmp(&fdata[i], &test_effect_preshader_fvect_v[i], sizeof(fdata[i])),
                        "Vertex shader float constants do not match, expected (%g, %g, %g, %g), "
                        "got (%g, %g, %g, %g), parameter %s.\n",
                        test_effect_preshader_fvect_v[i].x, test_effect_preshader_fvect_v[i].y,
                        test_effect_preshader_fvect_v[i].z, test_effect_preshader_fvect_v[i].w,
                        fdata[i].x, fdata[i].y, fdata[i].z, fdata[i].w, updated_param);
            }
            else
            {
                ok_(__FILE__, line)(!memcmp(&fdata[i], &fvect_filler, sizeof(fdata[i])),
                        "Vertex shader float constants updated unexpectedly, parameter %s.\n", updated_param);
            }
        }
    }
 
    for (i = ARRAY_SIZE(test_effect_preshader_fvect_v); i < 256; ++i)
    {
        hr = IDirect3DDevice9_GetVertexShaderConstantF(device, i, &fdata[0].x, 1);
        ok_(__FILE__, line)(hr == D3D_OK, "Got result %#lx.\n", hr);
        ok_(__FILE__, line)(!memcmp(fdata, &fvect_filler, sizeof(fvect_filler)),
                "Vertex shader float constants do not match.\n");
    }
}

test_effect_preshader_op_results_()

static void test_effect_preshader_op_results_ ( unsigned int  line, IDirect3DDevice9 *  device, const enum expected_state_update *  expected_state, const char *  updated_param  )

static

Definition at line 4507 of file effect.c.

{
    static const D3DCOLORVALUE black = {0.0f};
    unsigned int i, j;
    D3DLIGHT9 light;
    const float *v;
    HRESULT hr;
 
    for (i = 0; i < ARRAY_SIZE(test_effect_preshader_op_expected); ++i)
    {
        hr = IDirect3DDevice9_GetLight(device, i % 8, &light);
        ok_(__FILE__, line)(hr == D3D_OK, "Got result %#lx.\n", hr);
 
        v = i < 8 ? &light.Diffuse.r : (i < 16 ? &light.Ambient.r : &light.Specular.r);
        if (!expected_state || expected_state[i] == EXPECTED_STATE_UPDATED)
        {
            for (j = 0; j < 4; ++j)
            {
                todo_wine_if(test_effect_preshader_op_expected[i].todo[j])
                ok_(__FILE__, line)(compare_float(v[j],
                        ((const float *)test_effect_preshader_op_expected[i].result)[j],
                        test_effect_preshader_op_expected[i].ulps),
                        "Operation %s, component %u, expected %#x, got %#x (%g).\n",
                        test_effect_preshader_op_expected[i].comment, j,
                        test_effect_preshader_op_expected[i].result[j],
                        ((const unsigned int *)v)[j], v[j]);
            }
        }
        else if (expected_state[i] == EXPECTED_STATE_ZERO)
        {
            ok_(__FILE__, line)(!memcmp(v, &black, sizeof(black)),
                    "Parameter %s, test %d, operation %s, state updated unexpectedly.\n",
                    updated_param, i, test_effect_preshader_op_expected[i].comment);
        }
    }
}

test_effect_preshader_ops()

static void test_effect_preshader_ops ( IDirect3DDevice9 *  device )

static

Definition at line 5170 of file effect.c.

{
    static D3DLIGHT9 light;
    const struct
    {
        const char *mnem;
        unsigned int expected_result[4];
        unsigned int result_index;
        float *result;
        D3DXVECTOR4 opvect1, opvect2, opvect3;
        unsigned int ulps;
        BOOL todo[4];
    }
    op_tests[] =
    {
        {"exp", {0x3f800000, 0x3f800000, 0x3e5edc66, 0x7f800000}, 0, &light.Diffuse.r,
                {0.0f, -0.0f, -2.2f, 3.402823466e+38f}, {1.0f, 2.0f, -3.0f, 4.0f}},
        {"log", {0, 0x40000000, 0x3f9199b7, 0x43000000}, 1, &light.Diffuse.r,
                {0.0f, 4.0f, -2.2f, 3.402823466e+38f}, {1.0f, 2.0f, -3.0f, 4.0f}},
        {"asin", {0xbe9c00ad, 0xffc00000, 0xffc00000, 0xffc00000}, 2, &light.Diffuse.r,
                {-0.3f, 4.0f, -2.2f, 3.402823466e+38f}, {1.0f, 2.0f, -3.0f, 4.0f}},
        {"acos", {0x3ff01006, 0xffc00000, 0xffc00000, 0xffc00000}, 3, &light.Diffuse.r,
                {-0.3f, 4.0f, -2.2f, 3.402823466e+38f}, {1.0f, 2.0f, -3.0f, 4.0f}},
        {"atan", {0xbe9539d4, 0x3fa9b465, 0xbf927420, 0x3fc90fdb}, 4, &light.Diffuse.r,
                {-0.3f, 4.0f, -2.2f, 3.402823466e+38f}, {1.0f, 2.0f, -3.0f, 4.0f}},
        {"atan2 test #1", {0xbfc90fdb, 0x40490fdb, 0x80000000, 0x7fc00000}, 5, &light.Diffuse.r,
                {-0.3f, 0.0f, -0.0f, NAN}, {0.0f, -0.0f, 0.0f, 1.0f}},
        {"atan2 test #2", {0xbfc90fdb, 0, 0xc0490fdb, 0}, 5, &light.Diffuse.r,
                {-0.3f, 0.0f, -0.0f, -0.0f}, {-0.0f, 0.0f, -0.0f, 1.0f}},
        {"div", {0, 0, 0, 0}, 7, &light.Diffuse.r,
                {-0.3f, 0.0f, -2.2f, NAN}, {0.0f, -0.0f, -3.0f, 1.0f}},
        {"cmp", {0x40a00000, 0x40000000, 0x40400000, 0x41000000}, 0, &light.Ambient.r,
                {-0.3f, 0.0f, 2.2f, NAN}, {1.0f, 2.0f, 3.0f, 4.0f}, {5.0f, 6.0f, 7.0f, 8.0f}},
        {"0 * INF", {0xffc00000, 0xffc00000, 0xc0d33334, 0x7f800000}, 6, &light.Diffuse.r,
                {0.0f, -0.0f, -2.2f, 3.402823466e+38f}, {INFINITY, INFINITY, 3.0f, 4.0f}},
    };
    unsigned int i, j, passes_count;
    D3DXEFFECT_DESC desc;
    ID3DXEffect *effect;
    HRESULT hr;
 
    hr = D3DXCreateEffect(device, test_effect_preshader_ops_blob, sizeof(test_effect_preshader_ops_blob),
            NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetDesc(effect, &desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", desc.Creator);
    ok(!desc.Functions, "Unexpected value %u.\n", desc.Functions);
    ok(desc.Techniques == 1, "Unexpected value %u.\n", desc.Techniques);
    ok(desc.Parameters == 3, "Unexpected value %u.\n", desc.Parameters);
 
    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    for (i = 0; i < ARRAY_SIZE(op_tests); ++i)
    {
        const float *result = op_tests[i].result;
        const float *expected_float = (float *)op_tests[i].expected_result;
 
        winetest_push_context("Test %u", i);
        hr = effect->lpVtbl->SetVector(effect, "opvect1", &op_tests[i].opvect1);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        hr = effect->lpVtbl->SetVector(effect, "opvect2", &op_tests[i].opvect2);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        hr = effect->lpVtbl->SetVector(effect, "opvect3", &op_tests[i].opvect3);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        hr = effect->lpVtbl->CommitChanges(effect);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
        hr = IDirect3DDevice9_GetLight(device, op_tests[i].result_index, &light);
        ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
        for (j = 0; j < 4; ++j)
        {
            winetest_push_context("Light %u", j);
            todo_wine_if(op_tests[i].todo[j])
            ok(compare_float(result[j], expected_float[j], op_tests[i].ulps),
                    "Operation %s, component %u, expected %#x (%.8e), got %#x (%.8e).\n", op_tests[i].mnem,
                    j, op_tests[i].expected_result[j], expected_float[j],
                    ((unsigned int *)result)[j], result[j]);
            winetest_pop_context();
        }
        winetest_pop_context();
    }
 
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    effect->lpVtbl->Release(effect);
}

Referenced by START_TEST().

test_effect_preshader_relative_addressing()

static void test_effect_preshader_relative_addressing ( IDirect3DDevice9 *  device )

static

Definition at line 5963 of file effect.c.

{
    static const struct
    {
        D3DXVECTOR4 opvect2;
        D3DXVECTOR4 g_ivect;
        unsigned int expected[4];
    }
    test_out_of_bounds_index[] =
    {
        {{1.0f, 2.0f, 3.0f, 4.0f}, {101.0f, 101.0f, 101.0f, 101.0f}, {0, 0x42ca0000, 0x3f800000, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {3333.0f, 1094.0f, 2222.0f, 3333.0f},
                {0x447ac000, 0x45505000, 0x3f800000, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {3333.0f, 1094.0f, 2222.0f, 1.0f},
                {0x447ac000, 0x3f800000, 0x447a8000, 0x453b9000}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {1.0f, 1094.0f, 2222.0f, 3333.0f},
                {0x447ac000, 0x45505000, 0x3f800000, 0x453ba000}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {1111.0f, 1094.0f, 2222.0f, 1111.0f},
                {0x447ac000, 0x448ae000, 0, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {1111.0f, 1094.0f, 2222.0f, 3333.0f},
                {0x447ac000, 0x45505000, 0x3f800000, 0}},
        {{-1111.0f, 1094.0f, -2222.0f, -3333.0f}, {4.0f, 3.0f, 2.0f, 1.0f},
                {0x447ac000, 0x40800000, 0x447a8000, 0x453b9000}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-1.0f, -1.0f, -1.0f, -1.0f}, {0, 0xbf800000, 0, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-2.0f, -2.0f, -2.0f, -2.0f}, {0, 0xc0000000, 0x459c4800, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-3.0f, -3.0f, -3.0f, -3.0f}, {0, 0xc0400000, 0x453b9000, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-4.0f, -4.0f, -4.0f, -4.0f}, {0, 0xc0800000, 0x44fa2000, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-5.0f, -5.0f, -5.0f, -5.0f}, {0, 0xc0a00000, 0x459c5000, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-6.0f, -6.0f, -6.0f, -6.0f}, {0, 0xc0c00000, 0x453ba000, 0xc1400000}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-7.0f, -7.0f, -7.0f, -7.0f}, {0, 0xc0e00000, 0x44fa4000, 0x40400000}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-8.0f, -8.0f, -8.0f, -8.0f}, {0, 0xc1000000, 0, 0x44fa6000}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-9.0f, -9.0f, -9.0f, -9.0f}, {0, 0xc1100000, 0, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-10.0f, -10.0f, -10.0f, -10.0f}, {0, 0xc1200000, 0xc1200000, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-11.0f, -11.0f, -11.0f, -11.0f}, {0, 0xc1300000, 0x3f800000, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-12.0f, -12.0f, -12.0f, -12.0f}, {0, 0xc1400000, 0x447a4000, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {5.0f, 5.0f, 5.0f, 5.0f}, {0, 0x40a00000, 0x3f800000, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-1111.0f, 1094.0f, -2222.0f, -3333.0f},
                {0x447ac000, 0xc5505000, 0x459c5000, 0x40000000}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-3333.0f, 1094.0f, -2222.0f, -1111.0f},
                {0x447ac000, 0xc48ae000, 0x44fa4000, 0x3f800000}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-3333.0f, 1094.0f, -2222.0f, -3333.0f},
                {0x447ac000, 0xc5505000, 0x459c5000, 0}},
        {{1.0f, 2.0f, 3.0f, 4.0f}, {-1111.0f, 1094.0f, -2222.0f, -1111.0f},
                {0x447ac000, 0xc48ae000, 0x44fa4000, 0x40400000}},
    };
    static const struct
    {
        unsigned int zw[2];
    }
    expected_light_specular[] =
    {
        {{0, 0x44fa2000}},
        {{0x447a8000, 0x453b9000}},
        {{0x40000000, 0x459c4800}},
        {{0xbf800000, 0}},
        {{0x447a4000, 0}},
        {{0x3f800000, 0}},
        {{0xbf800000, 0}},
        {{0, 0}},
        {{0, 0x447a4000}},
        {{0x44fa4000, 0x3f800000}},
        {{0x453ba000, 0xbf800000}},
        {{0x459c5000, 0}},
        {{0x44fa2000, 0}},
        {{0x453b9000, 0}},
        {{0x459c4800, 0}},
        {{0, 0}},
    };
    static const struct
    {
        int index_value;
        unsigned int expected[4];
    }
    test_index_to_immediate_table[] =
    {
        {-1000000, {0, 0x40800000, 0x45bbd800, 0x41300000}},
        {-1001, {0x448d4000, 0x41300000, 0, 0}},
        {-32, {0x448d4000, 0x40800000, 0, 0}},
        {-31, {0x45843000, 0x41400000, 0, 0}},
        {-30, {0x46a64000, 0x41400000, 0x447a4000, 0x3f800000}},
        {-29, {0, 0x447a4000, 0x447a8000, 0x40000000}},
        {-28, {0, 0, 0x447ac000, 0x40400000}},
        {-27, {0, 0x3f800000, 0, 0}},
        {-26, {0, 0x41100000, 0x45bbd800, 0x41300000}},
        {-25, {0, 0x41300000, 0, 0}},
        {-24, {0, 0x41600000, 0, 0}},
        {-23, {0, 0, 0, 0}},
        {-22, {0, 0, 0, 0}},
        {-21, {0, 0x40a00000, 0, 0}},
        {-20, {0, 0x41500000, 0, 0}},
        {-19, {0, 0x41500000, 0, 0}},
        {-18, {0, 0xc1900000, 0, 0}},
        {-17, {0, 0, 0, 0}},
        {-16, {0, 0x40800000, 0, 0}},
        {-15, {0, 0x41400000, 0, 0}},
        {-14, {0, 0x41400000, 0, 0}},
        {-13, {0, 0x447a4000, 0x447a4000, 0x3f800000}},
        {-12, {0, 0, 0, 0}},
        {-11, {0, 0x3f800000, 0, 0}},
        {-10, {0, 0x41100000, 0, 0}},
        {-9, {0, 0x41300000, 0, 0}},
        {-8, {0, 0x41600000, 0, 0}},
        {-7, {0, 0, 0, 0}},
        {-6, {0, 0, 0, 0}},
        {-5, {0, 0x40a00000, 0, 0}},
        {-4, {0, 0x41500000, 0, 0}},
        {-3, {0, 0x41500000, 0, 0}},
        {-2, {0, 0xc0000000, 0, 0}},
        {-1, {0, 0, 0, 0}},
        {0, {0x45052000, 0x40800000, 0x447a4000, 0x3f800000}},
        {1, {0x467e6000, 0x41400000, 0x447a8000, 0x40000000}},
        {2, {0, 0x41400000, 0x447ac000, 0x40400000}},
        {3, {0, 0x447a4000, 0, 0}},
        {4, {0, 0, 0x45bbd800, 0x41300000}},
        {5, {0, 0x3f800000, 0, 0}},
        {6, {0, 0x41100000, 0, 0}},
        {7, {0, 0x41300000, 0, 0}},
        {8, {0, 0x41600000, 0, 0}},
        {9, {0, 0, 0, 0}},
        {10, {0, 0, 0, 0}},
        {11, {0, 0x40a00000, 0, 0}},
        {12, {0, 0x41500000, 0, 0}},
        {13, {0, 0x41500000, 0, 0}},
        {14, {0, 0x41600000, 0, 0}},
        {15, {0, 0, 0, 0}},
        {16, {0, 0x40800000, 0, 0}},
        {17, {0x45052000, 0x41400000, 0x447a4000, 0x3f800000}},
        {18, {0x467e6000, 0x41400000, 0x447a8000, 0x40000000}},
        {19, {0, 0x447a4000, 0x447ac000, 0x40400000}},
        {20, {0, 0, 0, 0}},
        {21, {0, 0x3f800000, 0x45bbd800, 0x41300000}},
        {22, {0, 0x41100000, 0, 0}},
        {23, {0, 0x41300000, 0, 0}},
        {24, {0, 0x41600000, 0, 0}},
        {25, {0, 0, 0, 0}},
        {26, {0, 0, 0, 0}},
        {27, {0, 0x40a00000, 0, 0}},
        {28, {0, 0x41500000, 0, 0}},
        {29, {0, 0x41500000, 0, 0}},
        {30, {0, 0x41f00000, 0, 0}},
        {31, {0, 0, 0, 0}},
        {1001, {0, 0, 0, 0}},
        {1000000, {0, 0x40800000, 0, 0}},
    };
    static const D3DLIGHT9 light_filler = {D3DLIGHT_POINT, {1.0f, 1.0f, 1.0f, 1.0f}, {1.0f, 1.0f, 1.0f, 1.0f},
            {1.0f, 1.0f, 1.0f, 1.0f}};
    unsigned int j, passes_count;
    const unsigned int *expected;
    const float *expected_float;
    ID3DXEffect *effect;
    D3DXVECTOR4 fvect;
    D3DLIGHT9 light;
    const float *v;
    HRESULT hr;
    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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    fvect.x = 1001.0f; fvect.y = 1002.0f; fvect.z = 1003.0f; fvect.w = 1004.0f;
    hr = effect->lpVtbl->SetVector(effect, "opvect1", &fvect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    fvect.x = 2001.0f; fvect.y = 2002.0f; fvect.z = 2003.0f; fvect.w = 2004.0f;
    hr = effect->lpVtbl->SetVector(effect, "g_Selector[0]", &fvect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    fvect.x = 3001.0f; fvect.y = 3002.0f; fvect.z = 3003.0f; fvect.w = 3004.0f;
    hr = effect->lpVtbl->SetVector(effect, "g_Selector[1]", &fvect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    v = &light.Specular.r;
    for (i = 0; i < ARRAY_SIZE(test_out_of_bounds_index); ++i)
    {
        hr = effect->lpVtbl->SetVector(effect, "opvect2", &test_out_of_bounds_index[i].opvect2);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
        hr = effect->lpVtbl->SetVector(effect, "g_iVect", &test_out_of_bounds_index[i].g_ivect);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
        hr = IDirect3DDevice9_SetLight(device, 1, &light_filler);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
        hr = effect->lpVtbl->CommitChanges(effect);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
        hr = IDirect3DDevice9_GetLight(device, 1, &light);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
        expected = test_out_of_bounds_index[i].expected;
        expected_float = (const float *)expected;
 
        for (j = 0; j < 4; ++j)
        {
            ok(compare_float(v[j], expected_float[j], 0),
                    "Test %d, component %u, expected %#x (%g), got %#x (%g).\n",
                    i, j, expected[j], expected_float[j], ((const unsigned int *)v)[j], v[j]);
        }
    }
 
    hr = effect->lpVtbl->SetVector(effect, "opvect2", &test_out_of_bounds_index[7].opvect2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetVector(effect, "g_iVect", &test_out_of_bounds_index[7].g_ivect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = IDirect3DDevice9_SetLight(device, 1, &light_filler);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    fvect = test_out_of_bounds_index[7].g_ivect;
    v = &light.Specular.b;
    for (i = -100; i < 100; ++i)
    {
        fvect.w = i;
        hr = effect->lpVtbl->SetVector(effect, "g_iVect", &fvect);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
        hr = effect->lpVtbl->CommitChanges(effect);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
        hr = IDirect3DDevice9_GetLight(device, 1, &light);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
        expected = expected_light_specular[(unsigned int)i % ARRAY_SIZE(expected_light_specular)].zw;
        expected_float = (const float *)expected;
 
        for (j = 0; j < 2; ++j)
        {
            ok(compare_float(v[j], expected_float[j], 0),
                    "i %d, component %u, expected %#x (%g), got %#x (%g).\n",
                    i, j + 2, expected[j], expected_float[j], ((const unsigned int *)v)[j], v[j]);
        }
    }
 
    v = &light.Specular.r;
    for (i = 0; i < ARRAY_SIZE(test_index_to_immediate_table); ++i)
    {
        fvect.x = fvect.y = fvect.z = fvect.w = test_index_to_immediate_table[i].index_value;
        hr = effect->lpVtbl->SetVector(effect, "g_iVect", &fvect);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
        hr = effect->lpVtbl->CommitChanges(effect);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
        hr = IDirect3DDevice9_GetLight(device, 2, &light);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
        expected = test_index_to_immediate_table[i].expected;
        expected_float = (const float *)expected;
 
        for (j = 0; j < 4; ++j)
        {
            ok(compare_float(v[j], expected_float[j], 0),
                    "Test %d, component %u, expected %#x (%g), got %#x (%g).\n",
                    i, j, expected[j], expected_float[j], ((const unsigned int *)v)[j], v[j]);
        }
    }
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    effect->lpVtbl->Release(effect);
}

Referenced by START_TEST().

test_effect_setvalue_object()

static void test_effect_setvalue_object ( IDirect3DDevice9 *  device )

static

Definition at line 2613 of file effect.c.

{
    static const char expected_string[] = "test_string_1";
    static const char expected_string2[] = "test_longer_string_2";
    static const char *expected_string_array[] = {expected_string, expected_string2};
    const char *string_array[ARRAY_SIZE(expected_string_array)];
    const char *string, *string2;
    IDirect3DTexture9 *texture_set;
    IDirect3DTexture9 *texture;
    D3DXHANDLE parameter;
    D3DXEFFECT_DESC desc;
    ID3DXEffect *effect;
    unsigned int i;
    ULONG count;
    HRESULT hr;
 
    hr = D3DXCreateEffect(device, test_effect_parameter_value_blob_object,
            sizeof(test_effect_parameter_value_blob_object), NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#lx, expected 0 (D3D_OK).\n", hr);
 
    hr = effect->lpVtbl->GetDesc(effect, &desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", desc.Creator);
    ok(!desc.Functions, "Unexpected value %u.\n", desc.Functions);
    ok(desc.Techniques == 1, "Unexpected value %u.\n", desc.Techniques);
    ok(desc.Parameters == 7, "Unexpected value %u.\n", desc.Parameters);
 
    parameter = effect->lpVtbl->GetParameterByName(effect, NULL, "tex");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    texture = NULL;
    hr = D3DXCreateTexture(device, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, 0, 0, D3DPOOL_DEFAULT, &texture);
    ok(hr == D3D_OK, "Got result %#lx, expected 0 (D3D_OK).\n", hr);
    hr = effect->lpVtbl->SetValue(effect, parameter, &texture, sizeof(texture));
    ok(hr == D3D_OK, "Got result %#lx, expected 0 (D3D_OK).\n", hr);
    texture_set = NULL;
    hr = effect->lpVtbl->GetValue(effect, parameter, &texture_set, sizeof(texture_set));
    ok(hr == D3D_OK, "Got result %#lx, expected 0 (D3D_OK).\n", hr);
    ok(texture == texture_set, "Texture does not match.\n");
 
    count = IDirect3DTexture9_Release(texture_set);
    ok(count == 2, "Got reference count %lu, expected 2.\n", count);
    texture_set = NULL;
    hr = effect->lpVtbl->SetValue(effect, parameter, &texture_set, sizeof(texture_set));
    ok(hr == D3D_OK, "Got result %#lx, expected 0 (D3D_OK).\n", hr);
    count = IDirect3DTexture9_Release(texture);
    ok(!count, "Got reference count %lu, expected 0.\n", count);
 
    hr = effect->lpVtbl->SetString(effect, "s", expected_string);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    string = NULL;
    hr = effect->lpVtbl->GetString(effect, "s", &string);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->GetString(effect, "s", &string2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    ok(string != expected_string, "String pointers are the same.\n");
    ok(string == string2, "String pointers differ.\n");
    ok(!strcmp(string, expected_string), "Unexpected string '%s'.\n", string);
 
    string = expected_string2;
    hr = effect->lpVtbl->SetValue(effect, "s", &string, sizeof(string) - 1);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetValue(effect, "s", &string, sizeof(string));
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetValue(effect, "s", &string, sizeof(string) * 2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    string = NULL;
    hr = effect->lpVtbl->GetValue(effect, "s", &string, sizeof(string));
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    ok(string != expected_string2, "String pointers are the same.\n");
    ok(!strcmp(string, expected_string2), "Unexpected string '%s'.\n", string);
 
    hr = effect->lpVtbl->SetValue(effect, "s_2", expected_string_array,
            sizeof(expected_string_array));
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->GetValue(effect, "s_2", string_array,
            sizeof(string_array));
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    for (i = 0; i < ARRAY_SIZE(expected_string_array); ++i)
    {
        ok(!strcmp(string_array[i], expected_string_array[i]), "Unexpected string '%s', i %u.\n",
                string_array[i], i);
    }
    effect->lpVtbl->Release(effect);
}

Referenced by START_TEST().

test_effect_shared_parameters()

static void test_effect_shared_parameters ( IDirect3DDevice9 *  device )

static

Definition at line 6773 of file effect.c.

{
    ID3DXEffect *effect1, *effect2, *effect3, *effect4;
    ID3DXEffectPool *pool;
    D3DXEFFECT_DESC desc;
    HRESULT hr;
    D3DXHANDLE param, param_child, param2, param_child2;
    unsigned int i, passes_count;
    ULONG refcount;
    D3DXVECTOR4 fvect;
    float fval[2];
 
    hr = D3DXCreateEffectPool(&pool);
    ok(hr == D3D_OK, "Got result %#lx.\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 result %#lx.\n", hr);
 
    hr = effect2->lpVtbl->GetDesc(effect2, &desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", desc.Creator);
    ok(!desc.Functions, "Unexpected value %u.\n", desc.Functions);
    ok(desc.Techniques == 1, "Unexpected value %u.\n", desc.Techniques);
    ok(desc.Parameters == 34, "Unexpected value %u.\n", desc.Parameters);
 
    effect2->lpVtbl->SetFloat(effect2, "arr2[0]", 28.0f);
    effect2->lpVtbl->Release(effect2);
 
    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 result %#lx.\n", hr);
    effect2->lpVtbl->GetFloat(effect2, "arr2[0]", &fvect.x);
    ok(fvect.x == 92.0f, "Unexpected parameter value %g.\n", fvect.x);
    effect2->lpVtbl->SetFloat(effect2, "arr2[0]", 28.0f);
 
    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob, sizeof(test_effect_preshader_effect_blob),
            NULL, NULL, 0, pool, &effect1, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    effect1->lpVtbl->GetFloat(effect1, "arr2[0]", &fvect.x);
    ok(fvect.x == 28.0f, "Unexpected parameter value %g.\n", fvect.x);
 
    hr = D3DXCreateEffect(device, test_effect_shared_parameters_blob, sizeof(test_effect_shared_parameters_blob),
            NULL, NULL, 0, pool, &effect3, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = D3DXCreateEffect(device, test_effect_shared_parameters_blob, sizeof(test_effect_shared_parameters_blob),
            NULL, NULL, 0, pool, &effect4, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    effect2->lpVtbl->SetFloat(effect2, "arr2[0]", 3.0f);
    effect2->lpVtbl->SetFloat(effect2, "ts2[0].fv", 3.0f);
 
    effect3->lpVtbl->GetFloat(effect3, "arr2[0]", &fvect.x);
    ok(fvect.x == 0.0f, "Unexpected parameter value %g.\n", fvect.x);
    effect4->lpVtbl->SetFloat(effect4, "arr2[0]", 28.0f);
    effect3->lpVtbl->GetFloat(effect3, "arr2[0]", &fvect.x);
    ok(fvect.x == 28.0f, "Unexpected parameter value %g.\n", fvect.x);
    effect1->lpVtbl->GetFloat(effect1, "arr2[0]", &fvect.x);
    ok(fvect.x == 3.0f, "Unexpected parameter value %g.\n", fvect.x);
 
    param = effect3->lpVtbl->GetParameterByName(effect3, NULL, "ts2[0].fv_2");
    ok(!!param, "GetParameterByName failed.\n");
    effect3->lpVtbl->GetFloat(effect3, param, &fvect.x);
    ok(fvect.x == 0.0f, "Unexpected parameter value %g.\n", fvect.x);
 
    param = effect1->lpVtbl->GetParameterByName(effect1, NULL, "arr2");
    ok(!!param, "GetParameterByName failed.\n");
    ok(!effect3->lpVtbl->IsParameterUsed(effect3, param, "tech0"),
            "Unexpected IsParameterUsed result.\n");
 
    param = effect3->lpVtbl->GetParameterByName(effect3, NULL, "arr2");
    ok(!!param, "GetParameterByName failed.\n");
    ok(effect3->lpVtbl->IsParameterUsed(effect3, param, "tech0"),
            "Unexpected IsParameterUsed result.\n");
 
    param = effect1->lpVtbl->GetParameterByName(effect1, NULL, "vs_arr2");
    ok(!!param, "GetParameterByName failed.\n");
    todo_wine
    ok(!effect3->lpVtbl->IsParameterUsed(effect3, param, "tech0"),
            "Unexpected IsParameterUsed result.\n");
 
    ok(effect3->lpVtbl->IsParameterUsed(effect3, "vs_arr2", "tech0"),
            "Unexpected IsParameterUsed result.\n");
    ok(!effect3->lpVtbl->IsParameterUsed(effect3, "vs_arr2[0]", "tech0"),
            "Unexpected IsParameterUsed result.\n");
    ok(!effect3->lpVtbl->IsParameterUsed(effect3, "vs_arr2[1]", "tech0"),
            "Unexpected IsParameterUsed result.\n");
 
    ok(effect1->lpVtbl->IsParameterUsed(effect1, param, "tech0"),
            "Unexpected IsParameterUsed result.\n");
 
    hr = effect3->lpVtbl->Begin(effect3, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    if (0)
    {
    /*  Native d3dx crashes in BeginPass(). This is the case of shader array declared shared
     *  but initialized with different shaders using different parameters. */
    hr = effect3->lpVtbl->BeginPass(effect3, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect3->lpVtbl->EndPass(effect3);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    }
 
    test_effect_clear_vconsts(device);
    fvect.x = fvect.y = fvect.z = fvect.w = 28.0f;
    hr = effect2->lpVtbl->SetVector(effect2, "g_Pos1", &fvect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect1->lpVtbl->SetVector(effect1, "g_Pos1", &fvect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect3->lpVtbl->BeginPass(effect3, 1);
    todo_wine
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 0, &fvect.x, 1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine
    ok(fvect.x == 0.0f && fvect.y == 0.0f && fvect.z == 0.0f && fvect.w == 0.0f,
            "Unexpected vector %g, %g, %g, %g.\n", fvect.x, fvect.y, fvect.z, fvect.w);
 
    hr = effect3->lpVtbl->EndPass(effect3);
    todo_wine
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect3->lpVtbl->End(effect3);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    for (i = 0; i < 2; ++i)
    {
        struct IDirect3DVertexShader9 *vshader1;
 
        param_child = effect1->lpVtbl->GetParameterElement(effect1, "vs_arr2", i);
        ok(!!param_child, "GetParameterElement failed.\n");
        hr = effect1->lpVtbl->GetVertexShader(effect1, param_child, &vshader1);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
        test_effect_shared_vs_arr_compare_helper(effect2, param_child, vshader1, i, FALSE);
        test_effect_shared_vs_arr_compare_helper(effect3, param_child, vshader1, i, FALSE);
        test_effect_shared_vs_arr_compare_helper(effect4, param_child, vshader1, i, FALSE);
        IDirect3DVertexShader9_Release(vshader1);
    }
 
    effect3->lpVtbl->Release(effect3);
    effect4->lpVtbl->Release(effect4);
 
    fval[0] = 1.0f;
    hr = effect1->lpVtbl->SetFloatArray(effect1, "arr1", fval, 1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    fval[0] = 0.0f;
    hr = effect2->lpVtbl->GetFloatArray(effect2, "arr1", fval, 1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(fval[0] == 91.0f, "Unexpected value %g.\n", fval[0]);
 
    param = effect1->lpVtbl->GetParameterByName(effect1, NULL, "arr2");
    ok(!!param, "GetParameterByName failed.\n");
    param2 = effect2->lpVtbl->GetParameterByName(effect2, NULL, "arr2");
    ok(!!param, "GetParameterByName failed.\n");
    ok(param != param2, "Got same parameter handle unexpectedly.\n");
    param_child = effect1->lpVtbl->GetParameterElement(effect1, param, 0);
    ok(!!param_child, "GetParameterElement failed.\n");
    param_child2 = effect1->lpVtbl->GetParameterElement(effect2, param2, 0);
    ok(!!param_child2, "GetParameterElement failed.\n");
    ok(param_child != param_child2, "Got same parameter handle unexpectedly.\n");
 
    fval[0] = 33.0f;
    hr = effect1->lpVtbl->SetFloatArray(effect1, "arr2", fval, 1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    fval[0] = 0.0f;
    hr = effect1->lpVtbl->GetFloatArray(effect1, "arr2", fval, 2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(fval[0] == 33.0f && fval[1] == 93.0f, "Unexpected values %g, %g.\n", fval[0], fval[1]);
    fval[0] = 0.0f;
    hr = effect2->lpVtbl->GetFloatArray(effect2, "arr2", fval, 2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    ok(fval[0] == 33.0f && fval[1] == 93.0f, "Unexpected values %g, %g.\n", fval[0], fval[1]);
 
    hr = effect1->lpVtbl->Begin(effect1, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect2->lpVtbl->Begin(effect2, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect1->lpVtbl->BeginPass(effect1, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    fvect.x = 1.0f;
    fvect.y = fvect.z = fvect.w = 0.0f;
    test_effect_shared_parameters_compare_vconst(device, 32, &fvect, FALSE);
 
    hr = effect1->lpVtbl->BeginPass(effect2, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    fvect.x = 91.0f;
    test_effect_shared_parameters_compare_vconst(device, 32, &fvect, FALSE);
    fvect.x = 33.0f;
    test_effect_shared_parameters_compare_vconst(device, 29, &fvect, FALSE);
 
    fval[0] = 28.0f;
    fval[1] = -1.0f;
    hr = effect1->lpVtbl->SetFloatArray(effect1, "arr2", fval, 2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    test_effect_clear_vconsts(device);
 
    hr = effect1->lpVtbl->CommitChanges(effect1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    fvect.x = 28.0f;
    test_effect_shared_parameters_compare_vconst(device, 29, &fvect, FALSE);
    fvect.x = -1.0f;
    test_effect_shared_parameters_compare_vconst(device, 30, &fvect, FALSE);
 
    test_effect_clear_vconsts(device);
 
    hr = effect1->lpVtbl->CommitChanges(effect1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    test_effect_shared_parameters_compare_vconst(device, 29, &fvect_filler, FALSE);
    test_effect_shared_parameters_compare_vconst(device, 30, &fvect_filler, FALSE);
 
    hr = effect2->lpVtbl->CommitChanges(effect2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    fvect.x = 28.0f;
    test_effect_shared_parameters_compare_vconst(device, 29, &fvect, FALSE);
    fvect.x = -1.0f;
    test_effect_shared_parameters_compare_vconst(device, 30, &fvect, FALSE);
 
    fval[0] = -2.0f;
    hr = effect2->lpVtbl->SetFloat(effect2, "arr2[0]", fval[0]);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect1->lpVtbl->CommitChanges(effect1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    fvect.x = -2.0f;
    test_effect_shared_parameters_compare_vconst(device, 29, &fvect, FALSE);
    fvect.x = -1.0f;
    test_effect_shared_parameters_compare_vconst(device, 30, &fvect, FALSE);
 
    fvect.x = fvect.y = fvect.z = fvect.w = 1111.0f;
    hr = effect2->lpVtbl->SetVector(effect2, "g_Pos1", &fvect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect1->lpVtbl->CommitChanges(effect1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    test_effect_shared_parameters_compare_vconst(device, 31, &fvect_filler, FALSE);
 
    hr = effect1->lpVtbl->CommitChanges(effect2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    test_effect_shared_parameters_compare_vconst(device, 31, &fvect, FALSE);
 
    hr = effect1->lpVtbl->End(effect1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect2->lpVtbl->End(effect2);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    if (0)
    {
        refcount = pool->lpVtbl->Release(pool);
        ok(refcount == 2, "Unexpected refcount %lu.\n", refcount);
 
        refcount = pool->lpVtbl->Release(pool);
        ok(refcount == 1, "Unexpected refcount %lu.\n", refcount);
 
        refcount = pool->lpVtbl->Release(pool);
        ok(!refcount, "Unexpected refcount %lu.\n", refcount);
 
        /* Native d3dx crashes in GetFloat(). */
        effect2->lpVtbl->GetFloat(effect2, "arr2[0]", &fvect.x);
    }
 
    effect1->lpVtbl->Release(effect1);
    effect2->lpVtbl->Release(effect2);
 
    refcount = pool->lpVtbl->Release(pool);
    ok(!refcount, "Effect pool was not properly freed, refcount %lu.\n", refcount);
}

Referenced by START_TEST().

test_effect_shared_parameters_compare_vconst_()

static void test_effect_shared_parameters_compare_vconst_ ( unsigned int  line, IDirect3DDevice9 *  device, unsigned int  index, const D3DXVECTOR4 *  expected_fvect, BOOL  todo  )

static

Definition at line 6760 of file effect.c.

{
    D3DXVECTOR4 fvect;
    HRESULT hr;
 
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, index, &fvect.x, 1);
    ok_(__FILE__, line)(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine_if(todo)
    ok_(__FILE__, line)(!memcmp(&fvect, expected_fvect, sizeof(fvect)),
            "Unexpected constant value %g, %g, %g, %g.\n", fvect.x, fvect.y, fvect.z, fvect.w);
}

test_effect_shared_vs_arr_compare_helper_()

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

Definition at line 6739 of file effect.c.

{
    struct IDirect3DVertexShader9 *vshader2;
    D3DXHANDLE param_child2;
    HRESULT hr;
 
    param_child2 = effect->lpVtbl->GetParameterElement(effect, "vs_arr2", element);
    ok_(__FILE__, line)(!!param_child2, "GetParameterElement failed.\n");
    ok_(__FILE__, line)(param_child != param_child2, "Got same parameter handle unexpectedly.\n");
    hr = effect->lpVtbl->GetVertexShader(effect, param_child2, &vshader2);
    ok_(__FILE__, line)(hr == D3D_OK, "Got result %#lx.\n", hr);
    todo_wine_if(todo)
    ok_(__FILE__, line)(vshader1 == vshader2, "Shared shader interface pointers differ.\n");
    if (vshader2)
        IDirect3DVertexShader9_Release(vshader2);
}

test_effect_skip_constants()

static void test_effect_skip_constants ( IDirect3DDevice9 *  device )

static

Definition at line 7247 of file effect.c.

{
    D3DXEFFECT_DESC desc;
    HRESULT hr;
    ID3DXEffect *effect;
    unsigned int passes_count;
    D3DXVECTOR4 fvect;
    unsigned int i;
 
    hr = D3DXCreateEffectEx(device, test_effect_skip_constants_blob, sizeof(test_effect_skip_constants_blob),
            NULL, NULL, "v3", 0, NULL, &effect, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
    hr = D3DXCreateEffectEx(device, test_effect_skip_constants_blob, sizeof(test_effect_skip_constants_blob),
            NULL, NULL, "v4", 0, NULL, &effect, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
    hr = D3DXCreateEffectEx(device, test_effect_skip_constants_blob, sizeof(test_effect_skip_constants_blob),
            NULL, NULL, "v1;v5;v4", 0, NULL, &effect, NULL);
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
 
    hr = D3DXCreateEffectEx(device, test_effect_skip_constants_blob, sizeof(test_effect_skip_constants_blob),
            NULL, NULL, " v1#,.+-= &\t\nv2*/!\"'v5 v6[1]", 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetDesc(effect, &desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", desc.Creator);
    ok(!desc.Functions, "Unexpected value %u.\n", desc.Functions);
    ok(desc.Techniques == 1, "Unexpected value %u.\n", desc.Techniques);
    ok(desc.Parameters == 6, "Unexpected value %u.\n", desc.Parameters);
 
    ok(!effect->lpVtbl->IsParameterUsed(effect, "v1", "tech0"),
            "Unexpected IsParameterUsed result.\n");
    ok(!effect->lpVtbl->IsParameterUsed(effect, "v2", "tech0"),
            "Unexpected IsParameterUsed result.\n");
    ok(effect->lpVtbl->IsParameterUsed(effect, "v3", "tech0"),
            "Unexpected IsParameterUsed result.\n");
    ok(effect->lpVtbl->IsParameterUsed(effect, "v4", "tech0"),
            "Unexpected IsParameterUsed result.\n");
    ok(!effect->lpVtbl->IsParameterUsed(effect, "v5", "tech0"),
            "Unexpected IsParameterUsed result.\n");
    ok(!effect->lpVtbl->IsParameterUsed(effect, "v6", "tech0"),
            "Unexpected IsParameterUsed result.\n");
 
    hr = effect->lpVtbl->SetFloat(effect, "v1", 28.0f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "v2", 29.0f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "v3", 30.0f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "v4", 31.0f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetFloat(effect, "v5", 32.0f);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    test_effect_clear_vconsts(device);
 
    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    fvect.y = fvect.z = fvect.w = 0.0f;
    fvect.x = 30.0f;
    test_effect_shared_parameters_compare_vconst(device, 0, &fvect, FALSE);
    for (i = 1; i < 4; ++i)
        test_effect_shared_parameters_compare_vconst(device, i, &fvect_filler, FALSE);
    fvect.x = 31.0f;
    test_effect_shared_parameters_compare_vconst(device, 4, &fvect, FALSE);
    for (i = 5; i < 256; ++i)
        test_effect_shared_parameters_compare_vconst(device, i, &fvect_filler, FALSE);
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    effect->lpVtbl->Release(effect);
}

Referenced by START_TEST().

test_effect_state_manager()

static void test_effect_state_manager ( IDirect3DDevice9 *  device )

static

Definition at line 6490 of file effect.c.

{
    static const struct test_state_manager_update expected_updates[] =
    {
        {2, 0, 0},
        {2, 1, 0},
        {2, 2, 0},
        {2, 3, 0},
        {2, 4, 0},
        {2, 5, 0},
        {2, 6, 0},
        {2, 7, 0},
        {3, 0, 0},
        {3, 1, 0},
        {3, 2, 0},
        {3, 3, 0},
        {3, 4, 0},
        {3, 5, 0},
        {3, 6, 0},
        {3, 7, 0},
        {4, 28, 0},
        {4, 36, 0},
        {4, 38, 0},
        {4, 158, 0},
        {4, 159, 0},
        {5, 0, 0},
        {5, 259, 0},
        {7, 0, 5},
        {7, 0, 6},
        {7, 1, 5},
        {7, 1, 6},
        {7, 257, 5},
        {7, 257, 6},
        {7, 258, 5},
        {7, 258, 6},
        {7, 259, 5},
        {7, 259, 6},
        {10, 0, 0},
        {11, 0, 34},
        {14, 0, 0},
        {15, 0, 14},
        {16, 0, 1},
        {17, 0, 6},
    };
    static D3DLIGHT9 light_filler =
            {D3DLIGHT_DIRECTIONAL, {0.5f, 0.5f, 0.5f, 0.5f}, {0.5f, 0.5f, 0.5f, 0.5f}, {0.5f, 0.5f, 0.5f, 0.5f}};
    struct test_manager *state_manager;
    unsigned int passes_count, i, n;
    ID3DXEffect *effect;
    ULONG refcount;
    HRESULT hr;
 
    state_manager = calloc(1, sizeof(*state_manager));
    test_effect_state_manager_init(state_manager, device);
 
    for (i = 0; i < 8; ++i)
    {
        hr = IDirect3DDevice9_SetLight(device, i, &light_filler);
        ok(hr == D3D_OK, "Got result %#lx.\n", 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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetStateManager(effect, &state_manager->ID3DXEffectStateManager_iface);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    effect->lpVtbl->Release(effect);
 
    qsort(state_manager->update_record, state_manager->update_record_count,
            sizeof(*state_manager->update_record), compare_update_record);
 
    ok(ARRAY_SIZE(expected_updates) == state_manager->update_record_count,
            "Got %u update records.\n", state_manager->update_record_count);
    n = min(ARRAY_SIZE(expected_updates), state_manager->update_record_count);
    for (i = 0; i < n; ++i)
    {
        ok(!memcmp(&expected_updates[i], &state_manager->update_record[i],
                sizeof(expected_updates[i])),
                "Update record mismatch, expected %s, %lu, %lu, got %s, %lu, %lu.\n",
                test_effect_state_manager_state_names[expected_updates[i].state_op],
                expected_updates[i].param1, expected_updates[i].param2,
                test_effect_state_manager_state_names[state_manager->update_record[i].state_op],
                state_manager->update_record[i].param1, state_manager->update_record[i].param2);
    }
 
    for (i = 0; i < 8; ++i)
    {
        D3DLIGHT9 light;
 
        hr = IDirect3DDevice9_GetLight(device, i, &light);
        ok(hr == D3D_OK, "Got result %#lx.\n", hr);
        ok(!memcmp(&light, &light_filler, sizeof(light)), "Light %u mismatch.\n", i);
    }
 
    refcount = state_manager->ID3DXEffectStateManager_iface.lpVtbl->Release(
            &state_manager->ID3DXEffectStateManager_iface);
    ok(!refcount, "State manager was not properly freed, refcount %lu.\n", refcount);
}

Referenced by START_TEST().

test_effect_state_manager_init()

static void test_effect_state_manager_init ( struct test_manager *  state_manager, IDirect3DDevice9 *  device  )

static

Definition at line 6419 of file effect.c.

{
    static const struct ID3DXEffectStateManagerVtbl test_ID3DXEffectStateManager_Vtbl =
    {
        /*** IUnknown methods ***/
        NULL,
        test_manager_AddRef,
        test_manager_Release,
        /*** ID3DXEffectStateManager methods ***/
        test_manager_SetTransform,
        test_manager_SetMaterial,
        test_manager_SetLight,
        test_manager_LightEnable,
        test_manager_SetRenderState,
        test_manager_SetTexture,
        test_manager_SetTextureStageState,
        test_manager_SetSamplerState,
        test_manager_SetNPatchMode,
        test_manager_SetFVF,
        test_manager_SetVertexShader,
        test_manager_SetVertexShaderConstantF,
        test_manager_SetVertexShaderConstantI,
        test_manager_SetVertexShaderConstantB,
        test_manager_SetPixelShader,
        test_manager_SetPixelShaderConstantF,
        test_manager_SetPixelShaderConstantI,
        test_manager_SetPixelShaderConstantB,
    };
 
    state_manager->ID3DXEffectStateManager_iface.lpVtbl = &test_ID3DXEffectStateManager_Vtbl;
    state_manager->ref = 1;
 
    IDirect3DDevice9_AddRef(device);
    state_manager->device = device;
}

Referenced by test_effect_clone(), and test_effect_state_manager().

test_effect_states()

static void test_effect_states ( IDirect3DDevice9 *  device )

static

Definition at line 3135 of file effect.c.

{
    static const D3DMATRIX test_mat =
    {{{
        -1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 0.0f
    }}};
    static const D3DMATRIX test_mat_camera =
    {{{
        4.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 6.0f
    }}};
    static const D3DMATRIX test_mat_world1 =
    {{{
        2.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 4.0f
    }}};
 
    IDirect3DVertexShader9 *vshader;
    D3DXEFFECT_DESC desc;
    ID3DXEffect *effect;
    UINT byte_code_size;
    D3DXVECTOR4 fvect;
    void *byte_code;
    D3DLIGHT9 light;
    D3DMATRIX mat;
    UINT npasses;
    DWORD value;
    HRESULT hr;
    BOOL bval;
 
    hr = D3DXCreateEffect(device, test_effect_states_effect_blob, sizeof(test_effect_states_effect_blob),
            NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->GetDesc(effect, &desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", desc.Creator);
    ok(!desc.Functions, "Unexpected value %u.\n", desc.Functions);
    ok(desc.Techniques == 1, "Unexpected value %u.\n", desc.Techniques);
    ok(desc.Parameters == 3, "Unexpected value %u.\n", desc.Parameters);
 
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3DERR_INVALIDCALL, "Unexpected hr %#lx.\n", hr);
 
    /* State affected in passes saved/restored even if no pass
       was performed. States not present in passes are not saved &
       restored */
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_BLENDOP, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHAFUNC, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->Begin(effect, &npasses, 0);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(npasses == 1, "Unexpected npasses %u.\n", npasses);
 
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_BLENDOP, 3);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHAFUNC, 2);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_BLENDOP, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == 1, "Unexpected value %lu.\n", value);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_ALPHAFUNC, &value);
    ok(value == 2, "Unexpected value %lu.\n", value);
 
    /* Test states application in BeginPass. No states are restored
       on EndPass. */
    hr = IDirect3DDevice9_SetSamplerState(device, 1, D3DSAMP_MIPFILTER, 0);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, 0);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetLightEnable(device, 2, &bval);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    if (hr == D3D_OK)
        ok(!bval, "Unexpected bval %#x.\n", bval);
 
    hr = IDirect3DDevice9_SetTransform(device, D3DTS_WORLDMATRIX(1), &test_mat);
    hr = effect->lpVtbl->Begin(effect, NULL, 0);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetTransform(device, D3DTS_WORLDMATRIX(1), &mat);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!memcmp(mat.m, test_mat.m, sizeof(mat)), "World matrix does not match.\n");
 
    test_effect_clear_vconsts(device);
 
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetTransform(device, D3DTS_WORLDMATRIX(1), &mat);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!memcmp(mat.m, test_mat_world1.m, sizeof(mat)), "World matrix does not match.\n");
 
    hr = IDirect3DDevice9_GetTransform(device, D3DTS_VIEW, &mat);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!memcmp(mat.m, test_mat_camera.m, sizeof(mat)), "View matrix does not match.\n");
 
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_BLENDOP, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == 2, "Unexpected value %lu.\n", value);
 
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(vshader != NULL, "Unexpected vshader %p.\n", vshader);
    hr = IDirect3DVertexShader9_GetFunction(vshader, NULL, &byte_code_size);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    byte_code = calloc(1, byte_code_size);
    hr = IDirect3DVertexShader9_GetFunction(vshader, byte_code, &byte_code_size);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(byte_code_size > 1, "Got unexpected byte code size %u.\n", byte_code_size);
    ok(!memcmp(byte_code, &test_effect_states_effect_blob[TEST_EFFECT_STATES_VSHADER_POS], byte_code_size),
            "Incorrect shader selected.\n");
    free(byte_code);
    IDirect3DVertexShader9_Release(vshader);
 
    hr = IDirect3DDevice9_GetLightEnable(device, 2, &bval);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(bval, "Unexpected bval %#x.\n", bval);
    hr = IDirect3DDevice9_GetLight(device, 2, &light);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(light.Position.x == 4.0f && light.Position.y == 5.0f && light.Position.z == 6.0f,
            "Unexpected light position (%.8e, %.8e, %.8e).\n", light.Position.x, light.Position.y, light.Position.z);
 
    /* Testing first value only for constants 1, 2 as the rest of the vector seem to
     * contain garbage data on native. */
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 1, &fvect.x, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(fvect.x == 3.0f, "Got unexpected vertex shader constant (%.8e, %.8e, %.8e, %.8e).\n",
            fvect.x, fvect.y, fvect.z, fvect.w);
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 2, &fvect.x, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(fvect.x == 1.0f, "Got unexpected vertex shader constant (%.8e, %.8e, %.8e, %.8e).\n",
            fvect.x, fvect.y, fvect.z, fvect.w);
 
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 3, &fvect.x, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(fvect.x == 2.0f && fvect.y == 2.0f && fvect.z == 2.0f && fvect.w == 2.0f,
            "Got unexpected vertex shader constant (%.8e, %.8e, %.8e, %.8e).\n",
            fvect.x, fvect.y, fvect.z, fvect.w);
 
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 4, &fvect.x, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(fvect.x == 4.0f && fvect.y == 4.0f && fvect.z == 4.0f && fvect.w == 4.0f,
            "Got unexpected vertex shader constant (%.8e, %.8e, %.8e, %.8e).\n",
            fvect.x, fvect.y, fvect.z, fvect.w);
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 5, &fvect.x, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(fvect.x == 0.0f && fvect.y == 0.0f && fvect.z == 0.0f && fvect.w == 0.0f,
            "Got unexpected vertex shader constant (%.8e, %.8e, %.8e, %.8e).\n",
            fvect.x, fvect.y, fvect.z, fvect.w);
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 6, &fvect.x, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(fvect.x == 0.0f && fvect.y == 0.0f && fvect.z == 0.0f && fvect.w == 0.0f,
            "Got unexpected vertex shader constant (%.8e, %.8e, %.8e, %.8e).\n",
            fvect.x, fvect.y, fvect.z, fvect.w);
    hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 7, &fvect.x, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!memcmp(&fvect, &fvect_filler, sizeof(fvect_filler)),
            "Got unexpected vertex shader constant (%.8e, %.8e, %.8e, %.8e).\n",
            fvect.x, fvect.y, fvect.z, fvect.w);
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_BLENDOP, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == 2, "Unexpected value %lu.\n", value);
 
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_ZENABLE, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value, "Unexpected value %lu.\n", value);
 
    hr = IDirect3DDevice9_GetSamplerState(device, 1, D3DSAMP_MIPFILTER, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == D3DTEXF_LINEAR, "Unexpected sampler 1 mipfilter %lu.\n", value);
 
    hr = IDirect3DDevice9_GetTextureStageState(device, 3, D3DTSS_ALPHAOP, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == 4, "Unexpected texture stage 3 AlphaOp %lu.\n", value);
 
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetTransform(device, D3DTS_WORLDMATRIX(1), &mat);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!memcmp(mat.m, test_mat.m, sizeof(mat)), "World matrix not restored.\n");
 
    hr = IDirect3DDevice9_GetLightEnable(device, 2, &bval);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!bval, "Unexpected bval %u.\n", bval);
 
    /* State is not restored if effect is released without End call */
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_BLENDOP, 1);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->Begin(effect, &npasses, 0);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    hr = IDirect3DDevice9_SetRenderState(device, D3DRS_BLENDOP, 3);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
 
    effect->lpVtbl->Release(effect);
 
    hr = IDirect3DDevice9_GetRenderState(device, D3DRS_BLENDOP, &value);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(value == 3, "Unexpected value %lu.\n", value);
}

Referenced by START_TEST().

test_effect_unsupported_shader()

static void test_effect_unsupported_shader ( void  )

static

Definition at line 7393 of file effect.c.

{
    IDirect3DVertexShader9 *vshader;
    unsigned int passes_count;
    IDirect3DDevice9 *device;
    UINT byte_code_size;
    ID3DXEffect *effect;
    void *byte_code;
    ULONG refcount;
    HWND window;
    HRESULT hr;
 
    if (!(device = create_device(&window)))
        return;
 
    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 %#lx.\n", hr);
 
    hr = effect->lpVtbl->ValidateTechnique(effect, "missing_technique");
    ok(hr == D3DERR_INVALIDCALL, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->ValidateTechnique(effect, "tech0");
    ok(hr == E_FAIL, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->ValidateTechnique(effect, "tech1");
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetInt(effect, "i", 1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->ValidateTechnique(effect, "tech1");
    ok(hr == E_FAIL, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->SetInt(effect, "i", 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->ValidateTechnique(effect, "tech1");
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetTechnique(effect, "tech0");
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %lx, expected 0 (D3D_OK).\n", hr);
    ok(!vshader, "Got non NULL vshader.\n");
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetTechnique(effect, "tech1");
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->Begin(effect, &passes_count, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
 
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %lx, expected 0 (D3D_OK).\n", hr);
    ok(!!vshader, "Got NULL vshader.\n");
    hr = IDirect3DVertexShader9_GetFunction(vshader, NULL, &byte_code_size);
    ok(hr == D3D_OK, "Got result %lx.\n", hr);
    byte_code = calloc(1, byte_code_size);
    hr = IDirect3DVertexShader9_GetFunction(vshader, byte_code, &byte_code_size);
    ok(hr == D3D_OK, "Got result %lx.\n", hr);
    ok(byte_code_size == TEST_EFFECT_UNSUPPORTED_SHADER_BYTECODE_VS_3_0_LEN * sizeof(DWORD),
            "Got unexpected byte code size %u.\n", byte_code_size);
    ok(!memcmp(byte_code,
            &test_effect_unsupported_shader_blob[TEST_EFFECT_UNSUPPORTED_SHADER_BYTECODE_VS_3_0_POS],
            byte_code_size), "Incorrect shader selected.\n");
    free(byte_code);
    IDirect3DVertexShader9_Release(vshader);
 
    hr = effect->lpVtbl->SetInt(effect, "i", 1);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = effect->lpVtbl->CommitChanges(effect);
    ok(hr == D3D_OK, "Got result %#lx.\n", hr);
    hr = IDirect3DDevice9_GetVertexShader(device, &vshader);
    ok(hr == D3D_OK, "Got result %lx.\n", hr);
    ok(!vshader, "Got non NULL vshader.\n");
 
    effect->lpVtbl->Release(effect);
 
    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %lu references left.\n", refcount);
    DestroyWindow(window);
}

Referenced by START_TEST().

test_effect_variable_names()

static void test_effect_variable_names ( IDirect3DDevice9 *  device )

static

Definition at line 2743 of file effect.c.

{
    D3DXEFFECT_DESC desc;
    ID3DXEffect *effect;
    ULONG count;
    HRESULT hr;
    D3DXHANDLE parameter, p;
 
    hr = D3DXCreateEffect(device, test_effect_variable_names_blob,
            sizeof(test_effect_variable_names_blob), NULL, NULL, 0, NULL, &effect, NULL);
    ok(hr == D3D_OK, "D3DXCreateEffect failed, got %#lx, expected %#lx\n", hr, D3D_OK);
 
    hr = effect->lpVtbl->GetDesc(effect, &desc);
    ok(hr == D3D_OK, "Unexpected hr %#lx.\n", hr);
    ok(!strcmp(desc.Creator, "D3DX Effect Compiler"), "Unexpected creator %s.\n", desc.Creator);
    ok(!desc.Functions, "Unexpected value %u.\n", desc.Functions);
    ok(desc.Techniques == 1, "Unexpected value %u.\n", desc.Techniques);
    ok(desc.Parameters == 6, "Unexpected value %u.\n", desc.Parameters);
 
    /*
     * check invalid calls
     * This will crash:
     * effect->lpVtbl->GetAnnotationByName(effect, "invalid1", "invalid2");
     */
    p = effect->lpVtbl->GetParameterByName(effect, NULL, NULL);
    ok(p == NULL, "GetParameterByName failed, got %p, expected %p\n", p, NULL);
 
    p = effect->lpVtbl->GetParameterByName(effect, NULL, "invalid1");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "invalid1", NULL);
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "invalid1", "invalid2");
    ok(p == NULL, "GetParameterByName failed, got %p, expected %p\n", p, NULL);
 
    /* float a; */
    parameter = effect->lpVtbl->GetParameterByName(effect, NULL, "a");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a", NULL);
    ok(parameter == p, "GetParameterByName failed, got %p, expected %p\n", p, parameter);
 
    /* members */
    p = effect->lpVtbl->GetParameterByName(effect, NULL, "a.");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a.", NULL);
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a", ".");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, NULL, "a.invalid");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a.invalid", NULL);
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a", ".invalid");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a.", "invalid");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a", "invalid");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    /* elements */
    p = effect->lpVtbl->GetParameterByName(effect, NULL, "a[]");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a[]", NULL);
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, NULL, "a[0]");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a[0]", NULL);
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a", "[0]");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterElement(effect, "a", 0);
    ok(p == NULL, "GetParameterElement failed, got %p\n", p);
 
    /* annotations */
    p = effect->lpVtbl->GetParameterByName(effect, NULL, "a@");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a@", NULL);
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a", "@invalid");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a@", "invalid");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, NULL, "a@invalid");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "a@invalid", NULL);
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetAnnotationByName(effect, "a", NULL);
    ok(p == NULL, "GetAnnotationByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetAnnotationByName(effect, "a", "invalid");
    ok(p == NULL, "GetAnnotationByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetAnnotation(effect, "a", 0);
    ok(p == NULL, "GetAnnotation failed, got %p\n", p);
 
    /* float b[1]; */
    parameter = effect->lpVtbl->GetParameterByName(effect, NULL, "b");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    p = effect->lpVtbl->GetParameterByName(effect, "b", NULL);
    ok(parameter == p, "GetParameterByName failed, got %p, expected %p\n", p, parameter);
 
    /* elements */
    p = effect->lpVtbl->GetParameterByName(effect, NULL, "b[]");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    parameter = effect->lpVtbl->GetParameterByName(effect, NULL, "b[0]");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    p = effect->lpVtbl->GetParameterByName(effect, "b[0]", NULL);
    ok(parameter == p, "GetParameterByName failed, got %p, expected %p\n", p, parameter);
 
    p = effect->lpVtbl->GetParameterElement(effect, "b", 0);
    ok(parameter == p, "GetParameterElement failed, got %p, expected %p\n", p, parameter);
 
    p = effect->lpVtbl->GetParameterByName(effect, "b", "[0]");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, NULL, "b[1]");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterElement(effect, "b", 1);
    ok(p == NULL, "GetParameterElement failed, got %p\n", p);
 
    /* float c <float d = 3;>; */
    parameter = effect->lpVtbl->GetParameterByName(effect, NULL, "c");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    p = effect->lpVtbl->GetParameterByName(effect, "c", NULL);
    ok(parameter == p, "GetParameterByName failed, got %p, expected %p\n", p, parameter);
 
    /* annotations */
    p = effect->lpVtbl->GetParameterByName(effect, "c", "@d");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "c@", "d");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, NULL, "c@invalid");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "c@invalid", NULL);
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetAnnotationByName(effect, "c", NULL);
    ok(p == NULL, "GetAnnotationByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetAnnotationByName(effect, "c", "invalid");
    ok(p == NULL, "GetAnnotationByName failed, got %p\n", p);
 
    parameter = effect->lpVtbl->GetParameterByName(effect, NULL, "c@d");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    p = effect->lpVtbl->GetParameterByName(effect, "c@d", NULL);
    ok(parameter == p, "GetParameterByName failed, got %p, expected %p\n", p, parameter);
 
    p = effect->lpVtbl->GetAnnotationByName(effect, "c", "d");
    ok(parameter == p, "GetAnnotationByName failed, got %p, expected %p\n", p, parameter);
 
    p = effect->lpVtbl->GetAnnotation(effect, "c", 0);
    ok(parameter == p, "GetAnnotation failed, got %p, expected %p\n", p, parameter);
 
    p = effect->lpVtbl->GetAnnotation(effect, "c", 1);
    ok(p == NULL, "GetAnnotation failed, got %p\n", p);
 
    /* struct {float e;} f; */
    parameter = effect->lpVtbl->GetParameterByName(effect, NULL, "f");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    p = effect->lpVtbl->GetParameterByName(effect, "f", NULL);
    ok(parameter == p, "GetParameterByName failed, got %p, expected %p\n", p, parameter);
 
    /* members */
    parameter = effect->lpVtbl->GetParameterByName(effect, NULL, "f.e");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    p = effect->lpVtbl->GetParameterByName(effect, "f.e", NULL);
    ok(parameter == p, "GetParameterByName failed, got %p, expected %p\n", p, parameter);
 
    p = effect->lpVtbl->GetParameterByName(effect, "f", "e");
    ok(parameter == p, "GetParameterByName failed, got %p, expected %p\n", p, parameter);
 
    p = effect->lpVtbl->GetParameterByName(effect, "f", ".e");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "f.", "e");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, "f.invalid", NULL);
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    p = effect->lpVtbl->GetParameterByName(effect, NULL, "f.invalid");
    ok(p == NULL, "GetParameterByName failed, got %p\n", p);
 
    /* float g <float h[1] = {3};>; */
    parameter = effect->lpVtbl->GetParameterByName(effect, NULL, "g@h[0]");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    p = effect->lpVtbl->GetAnnotationByName(effect, "g", "h[0]");
    ok(parameter == p, "GetAnnotationByName failed, got %p, expected %p\n", p, parameter);
 
    p = effect->lpVtbl->GetParameterElement(effect, "g@h", 0);
    ok(parameter == p, "GetParameterElement failed, got %p, expected %p\n", p, parameter);
 
    p = effect->lpVtbl->GetParameterElement(effect, effect->lpVtbl->GetAnnotation(effect, "g", 0), 0);
    ok(parameter == p, "GetParameterElement failed, got %p, expected %p\n", p, parameter);
 
    /* struct s {float j;}; float i <s k[1] = {4};>; */
    parameter = effect->lpVtbl->GetParameterByName(effect, NULL, "i@k[0].j");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    p = effect->lpVtbl->GetAnnotationByName(effect, "i", "k[0].j");
    ok(parameter == p, "GetAnnotationByName failed, got %p, expected %p\n", p, parameter);
 
    p = effect->lpVtbl->GetParameterByName(effect, effect->lpVtbl->GetParameterElement(effect, "i@k", 0), "j");
    ok(parameter == p, "GetParameterElement failed, got %p, expected %p\n", p, parameter);
 
    /* technique t <s l[1] = {5};> */
    parameter = effect->lpVtbl->GetAnnotationByName(effect, "t", "l[0].j");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    /* pass p <s m[1] = {6};> */
    parameter = effect->lpVtbl->GetAnnotationByName(effect, effect->lpVtbl->GetPassByName(effect, "t", "p"), "m[0].j");
    ok(parameter != NULL, "GetParameterByName failed, got %p\n", parameter);
 
    count = effect->lpVtbl->Release(effect);
    ok(!count, "Release failed %lu\n", count);
}

Referenced by START_TEST().

test_isparameterused_children()

static void test_isparameterused_children ( unsigned int  line, ID3DXEffect *  effect, D3DXHANDLE  tech, D3DXHANDLE  param  )

static

Definition at line 5262 of file effect.c.

{
    D3DXPARAMETER_DESC desc;
    D3DXHANDLE param_child;
    unsigned int i, child_count;
    HRESULT hr;
 
    hr = effect->lpVtbl->GetParameterDesc(effect, param, &desc);
    ok_(__FILE__, line)(hr == D3D_OK, "GetParameterDesc failed, result %#lx.\n", hr);
    child_count = desc.Elements ? desc.Elements : desc.StructMembers;
    for (i = 0; i < child_count; ++i)
    {
        param_child = desc.Elements ? effect->lpVtbl->GetParameterElement(effect, param, i)
                : effect->lpVtbl->GetParameter(effect, param, i);
        ok_(__FILE__, line)(!!param_child, "Failed getting child parameter %s[%u].\n", desc.Name, i);
        ok_(__FILE__, line)(!effect->lpVtbl->IsParameterUsed(effect, param_child, tech),
                "Unexpected IsParameterUsed() result for %s[%u].\n", desc.Name, i);
        test_isparameterused_children(line, effect, tech, param_child);
    }
}

Referenced by test_isparameterused_children(), and test_isparameterused_param_with_children_().

test_isparameterused_param_with_children_()

static void test_isparameterused_param_with_children_ ( unsigned int  line, ID3DXEffect *  effect, ID3DXEffect *  effect2, D3DXHANDLE  tech, const char *  name, BOOL  expected_result  )

static

Definition at line 5286 of file effect.c.

{
    D3DXHANDLE param;
 
    ok_(__FILE__, line)(effect->lpVtbl->IsParameterUsed(effect, (D3DXHANDLE)name, tech)
            == expected_result, "Unexpected IsParameterUsed() result for %s (referenced by name).\n", name);
 
    if (effect2)
        param = effect2->lpVtbl->GetParameterByName(effect2, NULL, name);
    else
        param = effect->lpVtbl->GetParameterByName(effect, NULL, name);
    ok_(__FILE__, line)(!!param, "GetParameterByName failed for %s.\n", name);
 
    ok_(__FILE__, line)(effect->lpVtbl->IsParameterUsed(effect, param, tech) == expected_result,
            "Unexpected IsParameterUsed() result for %s (referenced by handle).\n", name);
 
    test_isparameterused_children(line, effect, tech, param);
}

test_manager_AddRef()

static ULONG WINAPI test_manager_AddRef ( ID3DXEffectStateManager *  iface )

static

Definition at line 6264 of file effect.c.

{
    struct test_manager *state_manager = impl_from_ID3DXEffectStateManager(iface);
 
    return InterlockedIncrement(&state_manager->ref);
}

Referenced by test_effect_state_manager_init().

test_manager_LightEnable()

static HRESULT WINAPI test_manager_LightEnable ( ID3DXEffectStateManager *  iface, DWORD  index, BOOL  enable  )

static

Definition at line 6326 of file effect.c.

{
    struct test_manager *state_manager = impl_from_ID3DXEffectStateManager(iface);
 
    IDirect3DDevice9_LightEnable(state_manager->device, index, enable);
    return test_process_set_state(iface, 3, index, 0);
}

Referenced by test_effect_state_manager_init().

test_manager_Release()

static ULONG WINAPI test_manager_Release ( ID3DXEffectStateManager *  iface )

static

Definition at line 6271 of file effect.c.

{
    struct test_manager *state_manager = impl_from_ID3DXEffectStateManager(iface);
    ULONG ref = InterlockedDecrement(&state_manager->ref);
 
    if (!ref)
    {
        free_test_effect_state_manager(state_manager);
        free(state_manager);
    }
    return ref;
}

Referenced by test_effect_state_manager_init().

test_manager_SetFVF()

static HRESULT WINAPI test_manager_SetFVF ( ID3DXEffectStateManager *  iface, DWORD  format  )

static

Definition at line 6365 of file effect.c.

{
    return test_process_set_state(iface, 9, 0, 0);
}

Referenced by test_effect_state_manager_init().

test_manager_SetLight()

static HRESULT WINAPI test_manager_SetLight ( ID3DXEffectStateManager *  iface, DWORD  index, const D3DLIGHT9 *  light  )

static

Definition at line 6317 of file effect.c.

{
    struct test_manager *state_manager = impl_from_ID3DXEffectStateManager(iface);
 
    IDirect3DDevice9_SetLight(state_manager->device, index, light);
    return test_process_set_state(iface, 2, index, 0);
}

Referenced by test_effect_state_manager_init().

test_manager_SetMaterial()

static HRESULT WINAPI test_manager_SetMaterial ( ID3DXEffectStateManager *  iface, const D3DMATERIAL9 *  material  )

static

Definition at line 6311 of file effect.c.

{
    return test_process_set_state(iface, 1, 0, 0);
}

Referenced by test_effect_state_manager_init().

test_manager_SetNPatchMode()

static HRESULT WINAPI test_manager_SetNPatchMode ( ID3DXEffectStateManager *  iface, FLOAT  num_segments  )

static

Definition at line 6359 of file effect.c.

{
    return test_process_set_state(iface, 8, 0, 0);
}

Referenced by test_effect_state_manager_init().

test_manager_SetPixelShader()

static HRESULT WINAPI test_manager_SetPixelShader ( ID3DXEffectStateManager *  iface, struct IDirect3DPixelShader9 *  shader  )

static

Definition at line 6395 of file effect.c.

{
    return test_process_set_state(iface, 14, 0, 0);
}

Referenced by test_effect_state_manager_init().

test_manager_SetPixelShaderConstantB()

static HRESULT WINAPI test_manager_SetPixelShaderConstantB ( ID3DXEffectStateManager *  iface, UINT  register_index, const BOOL *  constant_data, UINT  register_count  )

static

Definition at line 6413 of file effect.c.

{
    return test_process_set_state(iface, 17, register_index, register_count);
}

Referenced by test_effect_state_manager_init().

test_manager_SetPixelShaderConstantF()

static HRESULT WINAPI test_manager_SetPixelShaderConstantF ( ID3DXEffectStateManager *  iface, UINT  register_index, const FLOAT *  constant_data, UINT  register_count  )

static

Definition at line 6401 of file effect.c.

{
    return test_process_set_state(iface, 15, register_index, register_count);
}

Referenced by test_effect_state_manager_init().

test_manager_SetPixelShaderConstantI()

static HRESULT WINAPI test_manager_SetPixelShaderConstantI ( ID3DXEffectStateManager *  iface, UINT  register_index, const INT *  constant_data, UINT  register_count  )

static

Definition at line 6407 of file effect.c.

{
    return test_process_set_state(iface, 16, register_index, register_count);
}

Referenced by test_effect_state_manager_init().

test_manager_SetRenderState()

static HRESULT WINAPI test_manager_SetRenderState ( ID3DXEffectStateManager *  iface, D3DRENDERSTATETYPE  state, DWORD  value  )

static

Definition at line 6335 of file effect.c.

{
    return test_process_set_state(iface, 4, state, 0);
}

Referenced by test_effect_state_manager_init().

test_manager_SetSamplerState()

static HRESULT WINAPI test_manager_SetSamplerState ( ID3DXEffectStateManager *  iface, DWORD  sampler, D3DSAMPLERSTATETYPE  type, DWORD  value  )

static

Definition at line 6353 of file effect.c.

{
    return test_process_set_state(iface, 7, sampler, type);
}

Referenced by test_effect_state_manager_init().

test_manager_SetTexture()

static HRESULT WINAPI test_manager_SetTexture ( ID3DXEffectStateManager *  iface, DWORD  stage, struct IDirect3DBaseTexture9 *  texture  )

static

Definition at line 6341 of file effect.c.

{
    return test_process_set_state(iface, 5, stage, 0);
}

Referenced by test_effect_state_manager_init().

test_manager_SetTextureStageState()

static HRESULT WINAPI test_manager_SetTextureStageState ( ID3DXEffectStateManager *  iface, DWORD  stage, D3DTEXTURESTAGESTATETYPE  type, DWORD  value  )

static

Definition at line 6347 of file effect.c.

{
    return test_process_set_state(iface, 6, stage, type);
}

Referenced by test_effect_state_manager_init().

test_manager_SetTransform()

static HRESULT WINAPI test_manager_SetTransform ( ID3DXEffectStateManager *  iface, D3DTRANSFORMSTATETYPE  state, const D3DMATRIX *  matrix  )

static

Definition at line 6305 of file effect.c.

{
    return test_process_set_state(iface, 0, state, 0);
}

Referenced by test_effect_state_manager_init().

test_manager_SetVertexShader()

static HRESULT WINAPI test_manager_SetVertexShader ( ID3DXEffectStateManager *  iface, struct IDirect3DVertexShader9 *  shader  )

static

Definition at line 6371 of file effect.c.

{
    return test_process_set_state(iface, 10, 0, 0);
}

Referenced by test_effect_state_manager_init().

test_manager_SetVertexShaderConstantB()

static HRESULT WINAPI test_manager_SetVertexShaderConstantB ( ID3DXEffectStateManager *  iface, UINT  register_index, const BOOL *  constant_data, UINT  register_count  )

static

Definition at line 6389 of file effect.c.

{
    return test_process_set_state(iface, 13, register_index, register_count);
}

Referenced by test_effect_state_manager_init().

test_manager_SetVertexShaderConstantF()

static HRESULT WINAPI test_manager_SetVertexShaderConstantF ( ID3DXEffectStateManager *  iface, UINT  register_index, const FLOAT *  constant_data, UINT  register_count  )

static

Definition at line 6377 of file effect.c.

{
    return test_process_set_state(iface, 11, register_index, register_count);
}

Referenced by test_effect_state_manager_init().

test_manager_SetVertexShaderConstantI()

static HRESULT WINAPI test_manager_SetVertexShaderConstantI ( ID3DXEffectStateManager *  iface, UINT  register_index, const INT *  constant_data, UINT  register_count  )

static

Definition at line 6383 of file effect.c.

{
    return test_process_set_state(iface, 12, register_index, register_count);
}

Referenced by test_effect_state_manager_init().

test_process_set_state()

static HRESULT test_process_set_state ( ID3DXEffectStateManager *  iface, unsigned int  state_op, DWORD  param1, DWORD  param2  )

static

Definition at line 6284 of file effect.c.

{
    struct test_manager *state_manager = impl_from_ID3DXEffectStateManager(iface);
 
    if (state_manager->update_record_count == state_manager->update_record_size)
    {
        if (!state_manager->update_record_size)
            state_manager->update_record_size = INITIAL_UPDATE_RECORD_SIZE;
        else
            state_manager->update_record_size *= 2;
        state_manager->update_record = realloc(state_manager->update_record,
                sizeof(*state_manager->update_record) * state_manager->update_record_size);
    }
    state_manager->update_record[state_manager->update_record_count].state_op = state_op;
    state_manager->update_record[state_manager->update_record_count].param1 = param1;
    state_manager->update_record[state_manager->update_record_count].param2 = param2;
    ++state_manager->update_record_count;
    return D3D_OK;
}

Referenced by test_manager_LightEnable(), test_manager_SetFVF(), test_manager_SetLight(), test_manager_SetMaterial(), test_manager_SetNPatchMode(), test_manager_SetPixelShader(), test_manager_SetPixelShaderConstantB(), test_manager_SetPixelShaderConstantF(), test_manager_SetPixelShaderConstantI(), test_manager_SetRenderState(), test_manager_SetSamplerState(), test_manager_SetTexture(), test_manager_SetTextureStageState(), test_manager_SetTransform(), test_manager_SetVertexShader(), test_manager_SetVertexShaderConstantB(), test_manager_SetVertexShaderConstantF(), and test_manager_SetVertexShaderConstantI().

test_refcount()

static void test_refcount ( void  )

static

Definition at line 7913 of file effect.c.

{
    IDirect3DTexture9 *texture, *cur_texture, *managed_texture, *sysmem_texture;
    unsigned int passes_count;
    IDirect3DDevice9 *device;
    ID3DXEffect *effect;
    ULONG refcount;
    HWND window;
    HRESULT hr;
 
    if (!(device = create_device(&window)))
        return;
 
    hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL);
    ok(hr == D3D_OK, "Failed to create texture, hr %#lx.\n", hr);
 
    hr = D3DXCreateEffect(device, test_effect_preshader_effect_blob,
            sizeof(test_effect_preshader_effect_blob), NULL, NULL,
            D3DXFX_DONOTSAVESTATE, NULL, &effect, NULL);
    ok(hr == D3D_OK, "Failed to create effect, hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->SetTexture(effect, "tex1", (IDirect3DBaseTexture9 *)texture);
    ok(hr == D3D_OK, "Failed to set texture parameter, hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->Begin(effect, &passes_count, D3DXFX_DONOTSAVESTATE);
    ok(hr == D3D_OK, "Begin() failed, hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "BeginPass() failed, hr %#lx.\n", hr);
 
    IDirect3DDevice9_GetTexture(device, 0, (IDirect3DBaseTexture9 **)&cur_texture);
    ok(cur_texture == texture, "Unexpected current texture %p.\n", cur_texture);
    IDirect3DTexture9_Release(cur_texture);
 
    IDirect3DDevice9_SetTexture(device, 0, NULL);
    effect->lpVtbl->CommitChanges(effect);
 
    IDirect3DDevice9_GetTexture(device, 0, (IDirect3DBaseTexture9 **)&cur_texture);
    ok(cur_texture == NULL, "Unexpected current texture %p.\n", cur_texture);
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "EndPass() failed, hr %#lx.\n", hr);
 
    hr = effect->lpVtbl->BeginPass(effect, 0);
    ok(hr == D3D_OK, "BeginPass() failed, hr %#lx.\n", hr);
 
    IDirect3DDevice9_GetTexture(device, 0, (IDirect3DBaseTexture9 **)&cur_texture);
    ok(cur_texture == texture, "Unexpected current texture %p.\n", cur_texture);
    IDirect3DTexture9_Release(cur_texture);
 
    hr = effect->lpVtbl->EndPass(effect);
    ok(hr == D3D_OK, "EndPass() failed, hr %#lx.\n", hr);
    hr = effect->lpVtbl->End(effect);
    ok(hr == D3D_OK, "End() failed, hr %#lx.\n", hr);
 
    IDirect3DDevice9_GetTexture(device, 0, (IDirect3DBaseTexture9 **)&cur_texture);
    ok(cur_texture == texture, "Unexpected current texture %p.\n", cur_texture);
    IDirect3DTexture9_Release(cur_texture);
    refcount = get_texture_refcount(texture);
    ok(refcount == 2, "Unexpected texture refcount %lu.\n", refcount);
 
    hr = effect->lpVtbl->OnLostDevice(effect);
    ok(hr == D3D_OK, "OnLostDevice() failed, hr %#lx.\n", hr);
    refcount = get_texture_refcount(texture);
    ok(refcount == 1, "Unexpected texture refcount %lu.\n", refcount);
 
    hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_MANAGED,
            &managed_texture, NULL);
    ok(hr == D3D_OK, "Failed to create texture, hr %#lx.\n", hr);
    effect->lpVtbl->SetTexture(effect, "tex1", (IDirect3DBaseTexture9 *)managed_texture);
 
    refcount = get_texture_refcount(managed_texture);
    ok(refcount == 2, "Unexpected texture refcount %lu.\n", refcount);
    hr = effect->lpVtbl->OnLostDevice(effect);
    ok(hr == D3D_OK, "OnLostDevice() failed, hr %#lx.\n", hr);
    refcount = get_texture_refcount(managed_texture);
    ok(refcount == 2, "Unexpected texture refcount %lu.\n", refcount);
 
    hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM,
            &sysmem_texture, NULL);
    ok(hr == D3D_OK, "Failed to create texture, hr %#lx.\n", hr);
    effect->lpVtbl->SetTexture(effect, "tex1", (IDirect3DBaseTexture9 *)sysmem_texture);
 
    refcount = get_texture_refcount(managed_texture);
    ok(refcount == 1, "Unexpected texture refcount %lu.\n", refcount);
    IDirect3DTexture9_Release(managed_texture);
    refcount = get_texture_refcount(sysmem_texture);
    ok(refcount == 2, "Unexpected texture refcount %lu.\n", refcount);
    hr = effect->lpVtbl->OnLostDevice(effect);
    ok(hr == D3D_OK, "OnLostDevice() failed, hr %#lx.\n", hr);
    refcount = get_texture_refcount(sysmem_texture);
    ok(refcount == 2, "Unexpected texture refcount %lu.\n", refcount);
 
    effect->lpVtbl->Release(effect);
 
    refcount = get_texture_refcount(sysmem_texture);
    ok(refcount == 1, "Unexpected texture refcount %lu.\n", refcount);
    IDirect3DTexture9_Release(sysmem_texture);
 
    IDirect3DDevice9_GetTexture(device, 0, (IDirect3DBaseTexture9 **)&cur_texture);
    ok(cur_texture == texture, "Unexpected current texture %p.\n", cur_texture);
    IDirect3DTexture9_Release(cur_texture);
    refcount = get_texture_refcount(texture);
    ok(refcount == 1, "Unexpected texture refcount %lu.\n", refcount);
    IDirect3DTexture9_Release(texture);
 
    refcount = IDirect3DDevice9_Release(device);
    ok(!refcount, "Device has %lu references left.\n", refcount);
    DestroyWindow(window);
}

Referenced by START_TEST().

Variable Documentation

blob

const DWORD* blob

Definition at line 1152 of file effect.c.

blob_size

UINT blob_size

Definition at line 1153 of file effect.c.

Referenced by d3d12_device_CreatePipelineLibrary(), parse_fx10_property_assignment(), and test_effect_parameter_value().

comment

const char* comment

Definition at line 4464 of file effect.c.

d3dxinclude_vtbl

const struct ID3DXIncludeVtbl d3dxinclude_vtbl

static

Initial value:

=
{
    d3dxinclude_open,
    d3dxinclude_close
}

Definition at line 8112 of file effect.c.

Referenced by test_create_effect_from_file().

effect_desc

const char effect_desc[]

static

Initial value:

=
"Technique\n"
"{\n"
"}\n"

Definition at line 232 of file effect.c.

Referenced by test_create_effect_and_pool(), test_create_effect_compiler(), and test_effect_find_next_valid_technique().

fvect_filler

const D3DXVECTOR4 fvect_filler = {-9999.0f, -9999.0f, -9999.0f, -9999.0f}

static

Definition at line 3121 of file effect.c.

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

res

const struct test_effect_parameter_value_result* res

Definition at line 1154 of file effect.c.

res_count

UINT res_count

Definition at line 1155 of file effect.c.

Referenced by test_effect_parameter_value().

result

unsigned int result[4]

Definition at line 4466 of file effect.c.

Referenced by test_effect_preshader_ops().

temp_path

char temp_path[MAX_PATH]

static

Definition at line 175 of file effect.c.

Referenced by create_directory(), create_file(), delete_directory(), and delete_file().

test_effect_null_shader_blob

const DWORD test_effect_null_shader_blob[]

static

Initial value:

=
{
    0xfeff0901, 0x000000b4, 0x00000000, 0x00000010, 0x00000004, 0x00000020, 0x00000000, 0x00000002,
    0x00000001, 0x00000002, 0x00000007, 0x615f7376, 0x00007272, 0x00000002, 0x00000000, 0x0000004c,
    0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x00000000, 0x00000002, 0x00000069, 0x00000000,
    0x00000002, 0x00000002, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x00000003,
    0x00003070, 0x00000006, 0x68636574, 0x00000030, 0x00000003, 0x00000010, 0x00000004, 0x00000000,
    0x00000000, 0x00000000, 0x00000003, 0x00003070, 0x00000006, 0x68636574, 0x00000031, 0x00000002,
    0x00000002, 0x00000005, 0x00000004, 0x00000004, 0x00000018, 0x00000000, 0x00000000, 0x0000002c,
    0x00000048, 0x00000000, 0x00000000, 0x0000007c, 0x00000000, 0x00000001, 0x00000074, 0x00000000,
    0x00000001, 0x00000092, 0x00000000, 0x00000058, 0x00000054, 0x000000a8, 0x00000000, 0x00000001,
    0x000000a0, 0x00000000, 0x00000001, 0x00000092, 0x00000000, 0x0000008c, 0x00000088, 0x00000002,
    0x00000001, 0x00000001, 0x00000000, 0x00000002, 0x00000000, 0x00000001, 0x00000000, 0xffffffff,
    0x00000000, 0x00000002, 0x000000e4, 0x00000008, 0x615f7376, 0x00007272, 0x46580200, 0x0023fffe,
    0x42415443, 0x0000001c, 0x00000057, 0x46580200, 0x00000001, 0x0000001c, 0x00000100, 0x00000054,
    0x00000030, 0x00000002, 0x00000001, 0x00000034, 0x00000044, 0xabab0069, 0x00020000, 0x00010001,
    0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x4d007874, 0x6f726369,
    0x74666f73, 0x29522820, 0x534c4820, 0x6853204c, 0x72656461, 0x6d6f4320, 0x656c6970, 0x2e392072,
    0x392e3932, 0x332e3235, 0x00313131, 0x0002fffe, 0x54494c43, 0x00000000, 0x000cfffe, 0x434c5846,
    0x00000001, 0x10000001, 0x00000001, 0x00000000, 0x00000002, 0x00000000, 0x00000000, 0x00000004,
    0x00000000, 0xf0f0f0f0, 0x0f0f0f0f, 0x0000ffff,
}

Definition at line 7502 of file effect.c.

Referenced by test_effect_null_shader().

test_effect_parameter_value_blob_float

const DWORD test_effect_parameter_value_blob_float[]

static

Definition at line 506 of file effect.c.

Referenced by test_effect_parameter_block().

test_effect_parameter_value_blob_int

const DWORD test_effect_parameter_value_blob_int[]

static

Definition at line 811 of file effect.c.

test_effect_parameter_value_blob_object

const DWORD test_effect_parameter_value_blob_object[]

static

Initial value:

=
{
0xfeff0901, 0x00000100, 0x00000000, 0x00000004, 0x00000004, 0x0000001c, 0x00000000, 0x00000000,
0x00000001, 0x00000002, 0x00000073, 0x00000004, 0x00000004, 0x00000040, 0x00000000, 0x00000002,
0x00000002, 0x00000003, 0x00000004, 0x00325f73, 0x00000007, 0x00000004, 0x00000060, 0x00000000,
0x00000000, 0x00000004, 0x00000004, 0x00786574, 0x00000010, 0x00000004, 0x00000080, 0x00000000,
0x00000000, 0x00000005, 0x00000002, 0x00000076, 0x00000010, 0x00000004, 0x000000a4, 0x00000000,
0x00000002, 0x00000006, 0x00000007, 0x00000004, 0x00325f76, 0x0000000f, 0x00000004, 0x000000c4,
0x00000000, 0x00000000, 0x00000008, 0x00000002, 0x00000070, 0x0000000f, 0x00000004, 0x000000e8,
0x00000000, 0x00000002, 0x00000009, 0x0000000a, 0x00000004, 0x00325f70, 0x00000002, 0x00000070,
0x00000002, 0x00000074, 0x00000007, 0x00000001, 0x00000007, 0x0000000b, 0x00000004, 0x00000018,
0x00000000, 0x00000000, 0x00000024, 0x00000038, 0x00000000, 0x00000000, 0x00000048, 0x0000005c,
0x00000000, 0x00000000, 0x00000068, 0x0000007c, 0x00000000, 0x00000000, 0x00000088, 0x0000009c,
0x00000000, 0x00000000, 0x000000ac, 0x000000c0, 0x00000000, 0x00000000, 0x000000cc, 0x000000e0,
0x00000000, 0x00000000, 0x000000f8, 0x00000000, 0x00000001, 0x000000f0, 0x00000000, 0x00000000,
0x0000000a, 0x00000000, 0x00000009, 0x00000000, 0x0000000a, 0x00000000, 0x00000008, 0x00000000,
0x00000006, 0x00000000, 0x00000007, 0x00000000, 0x00000005, 0x00000000, 0x00000004, 0x00000000,
0x00000002, 0x00000006, 0x74736574, 0x00000031, 0x00000003, 0x00000006, 0x74736574, 0x00000032,
0x00000001, 0x00000005, 0x74736574, 0x00000000,
}

Definition at line 1069 of file effect.c.

Referenced by test_effect_setvalue_object().

test_effect_parameter_value_blob_special

const DWORD test_effect_parameter_value_blob_special[]

static

Initial value:

=
{
0xfeff0901, 0x00000150, 0x00000000, 0x00000003, 0x00000001, 0x0000002c, 0x00000000, 0x00000000,
0x00000003, 0x00000001, 0xc0466666, 0x43193333, 0x438da666, 0x00000003, 0x00003366, 0x00000003,
0x00000001, 0x0000005c, 0x00000000, 0x00000000, 0x00000003, 0x00000001, 0xc1f8cccd, 0xc1f9999a,
0xc1fa6666, 0x00000006, 0x696d3366, 0x0000006e, 0x00000003, 0x00000001, 0x00000090, 0x00000000,
0x00000000, 0x00000003, 0x00000001, 0x43a00ccd, 0x43a0199a, 0x43a02666, 0x00000006, 0x616d3366,
0x00000078, 0x00000003, 0x00000001, 0x000000c8, 0x00000000, 0x00000000, 0x00000004, 0x00000001,
0xc0833333, 0x431a3333, 0x438e2666, 0x4209999a, 0x00000003, 0x00003466, 0x00000003, 0x00000001,
0x000000fc, 0x00000000, 0x00000000, 0x00000004, 0x00000001, 0xc2246666, 0xc224cccd, 0xc2253333,
0xc225999a, 0x00000006, 0x696d3466, 0x0000006e, 0x00000003, 0x00000001, 0x00000134, 0x00000000,
0x00000000, 0x00000004, 0x00000001, 0x43d20ccd, 0x4228cccd, 0x43d22666, 0x43d23333, 0x00000006,
0x616d3466, 0x00000078, 0x00000002, 0x00000070, 0x00000002, 0x00000074, 0x00000006, 0x00000001,
0x00000001, 0x00000001, 0x00000004, 0x00000020, 0x00000000, 0x00000000, 0x00000034, 0x00000050,
0x00000000, 0x00000000, 0x00000068, 0x00000084, 0x00000000, 0x00000000, 0x0000009c, 0x000000b8,
0x00000000, 0x00000000, 0x000000d0, 0x000000ec, 0x00000000, 0x00000000, 0x00000108, 0x00000124,
0x00000000, 0x00000000, 0x00000148, 0x00000000, 0x00000001, 0x00000140, 0x00000000, 0x00000000,
0x00000000, 0x00000000,
}

Definition at line 1113 of file effect.c.

const struct { ... } test_effect_parameter_value_data[]

Initial value:

=
{
    ADD_PARAMETER_VALUE(float),
    ADD_PARAMETER_VALUE(int),
    ADD_PARAMETER_VALUE(object),
    ADD_PARAMETER_VALUE(special),
}

Referenced by test_effect_parameter_value().

test_effect_parameter_value_result_float

const struct test_effect_parameter_value_result test_effect_parameter_value_result_float[]

static

Definition at line 625 of file effect.c.

test_effect_parameter_value_result_int

const struct test_effect_parameter_value_result test_effect_parameter_value_result_int[]

static

Definition at line 930 of file effect.c.

test_effect_parameter_value_result_object

const struct test_effect_parameter_value_result test_effect_parameter_value_result_object[]

static

Initial value:

=
{
    { "s",   D3DXPC_OBJECT, D3DXPT_STRING,       0, 0, 0, sizeof(void *)     },
    { "s_2", D3DXPC_OBJECT, D3DXPT_STRING,       0, 0, 2, 2 * sizeof(void *) },
    { "tex", D3DXPC_OBJECT, D3DXPT_TEXTURE2D,    0, 0, 0, sizeof(void *)     },
    { "v",   D3DXPC_OBJECT, D3DXPT_VERTEXSHADER, 0, 0, 0, sizeof(void *)     },
    { "v_2", D3DXPC_OBJECT, D3DXPT_VERTEXSHADER, 0, 0, 2, 2 * sizeof(void *) },
    { "p",   D3DXPC_OBJECT, D3DXPT_PIXELSHADER,  0, 0, 0, sizeof(void *)     },
    { "p_2", D3DXPC_OBJECT, D3DXPT_PIXELSHADER,  0, 0, 2, 2 * sizeof(void *) },
}

Definition at line 1090 of file effect.c.

test_effect_parameter_value_result_special

const struct test_effect_parameter_value_result test_effect_parameter_value_result_special[]

static

Initial value:

=
{
    { "f3",    D3DXPC_VECTOR, D3DXPT_FLOAT, 1, 3, 0, 12, { .f = { -3.1f, 153.2f, 283.3f }} },
    { "f3min", D3DXPC_VECTOR, D3DXPT_FLOAT, 1, 3, 0, 12, { .f = { -31.1f, -31.2f, -31.3f }} },
    { "f3max", D3DXPC_VECTOR, D3DXPT_FLOAT, 1, 3, 0, 12, { .f = { 320.1f, 320.2f, 320.3f }} },
    { "f4",    D3DXPC_VECTOR, D3DXPT_FLOAT, 1, 4, 0, 16, { .f = { -4.1f, 154.2f, 284.3f, 34.4f }} },
    { "f4min", D3DXPC_VECTOR, D3DXPT_FLOAT, 1, 4, 0, 16, { .f = { -41.1f, -41.2f, -41.3f, -41.4f }} },
    { "f4max", D3DXPC_VECTOR, D3DXPT_FLOAT, 1, 4, 0, 16, { .f = { 420.1f, 42.20f, 420.3f, 420.4f }} },
}

Definition at line 1133 of file effect.c.

test_effect_preshader_bconsts

const BOOL test_effect_preshader_bconsts[]

static

Initial value:

=
{
    TRUE, FALSE, TRUE, FALSE, TRUE, TRUE
}

Definition at line 4633 of file effect.c.

Referenced by test_effect_commitchanges(), test_effect_preshader_clear_pbool_consts(), and test_effect_preshader_compare_pbool_consts_().

test_effect_preshader_effect_blob

const DWORD test_effect_preshader_effect_blob[]

static

Definition at line 3609 of file effect.c.

Referenced by test_cross_effect_handle(), test_effect_commitchanges(), test_effect_get_pass_desc(), test_effect_isparameterused(), test_effect_large_address_aware_flag(), test_effect_out_of_bounds_selector(), test_effect_parameter_block(), test_effect_preshader(), test_effect_preshader_compare_shader_bytecode_(), test_effect_preshader_relative_addressing(), test_effect_shared_parameters(), test_effect_state_manager(), and test_refcount().

test_effect_preshader_fvect_v

const D3DXVECTOR4 test_effect_preshader_fvect_v[]

static

Definition at line 4545 of file effect.c.

Referenced by test_effect_commitchanges(), and test_effect_preshader_compare_vconsts_().

const struct { ... } test_effect_preshader_op_expected[]

Initial value:

=
{
    {"1 / op", {FALSE, FALSE, FALSE, FALSE}, {0x7f800000, 0xff800000, 0xbee8ba2e, 0x00200000}},
    {"rsq",    {FALSE, FALSE, FALSE, FALSE}, {0x7f800000, 0x7f800000, 0x3f2c985c, 0x1f800001}, 1},
    {"mul",    {FALSE, FALSE, FALSE, FALSE}, {0x00000000, 0x80000000, 0x40d33334, 0x7f800000}},
    {"add",    {FALSE, FALSE, FALSE, FALSE}, {0x3f800000, 0x40000000, 0xc0a66666, 0x7f7fffff}},
    {"lt",     {FALSE, FALSE, FALSE, FALSE}, {0x3f800000, 0x3f800000, 0x00000000, 0x00000000}},
    {"ge",     {FALSE, FALSE, FALSE, FALSE}, {0x00000000, 0x00000000, 0x3f800000, 0x3f800000}},
    {"neg",    {FALSE, FALSE, FALSE, FALSE}, {0x80000000, 0x00000000, 0x400ccccd, 0xff7fffff}},
    {"rcp",    {FALSE, FALSE, FALSE, FALSE}, {0x7f800000, 0xff800000, 0xbee8ba2e, 0x00200000}},
 
    {"frac",   {FALSE, FALSE, FALSE, FALSE}, {0x00000000, 0x00000000, 0x3f4ccccc, 0x00000000}},
    {"min",    {FALSE, FALSE, FALSE, FALSE}, {0x00000000, 0x80000000, 0xc0400000, 0x40800000}},
    {"max",    {FALSE, FALSE, FALSE, FALSE}, {0x3f800000, 0x40000000, 0xc00ccccd, 0x7f7fffff}},
 
 
 
 
    {"sin",    {FALSE, FALSE, FALSE,  TRUE}, {0x00000000, 0x80000000, 0xbf4ef99e, 0x3f792dc4}},
    {"cos",    {FALSE, FALSE, FALSE,  TRUE}, {0x3f800000, 0x3f800000, 0xbf16a803, 0xbe6acefc}},
 
    {"den mul",{FALSE, FALSE, FALSE, FALSE}, {0x7f800000, 0xff800000, 0xbb94f209, 0x000051ec}},
    {"dot",    {FALSE, FALSE, FALSE, FALSE}, {0x00000000, 0x7f800000, 0x41f00000, 0x00000000}},
    {"prec",   {FALSE, FALSE,  TRUE, FALSE}, {0x2b8cbccc, 0x2c0cbccc, 0xac531800, 0x00000000}},
 
    {"dotswiz", {FALSE, FALSE, FALSE, FALSE}, {0xc00ccccd, 0xc0d33334, 0xc10ccccd, 0}},
    {"reladdr", {FALSE, FALSE, FALSE, FALSE}, {0xc00ccccd, 0x3f800000, 0, 0x41200000}},
    {"reladdr2", {FALSE, FALSE, FALSE, FALSE}, {0, 0, 0x447ac000, 0x40000000}},
}

Referenced by test_effect_commitchanges(), and test_effect_preshader_op_results_().

test_effect_preshader_ops_blob

const DWORD test_effect_preshader_ops_blob[]

static

Definition at line 5008 of file effect.c.

Referenced by test_effect_preshader_ops().

test_effect_shared_parameters_blob

const DWORD test_effect_shared_parameters_blob[]

static

Definition at line 6682 of file effect.c.

Referenced by test_effect_shared_parameters().

test_effect_skip_constants_blob

const DWORD test_effect_skip_constants_blob[]

static

Definition at line 7205 of file effect.c.

Referenced by test_effect_skip_constants().

test_effect_state_manager_state_names

const char* test_effect_state_manager_state_names[]

static

Initial value:

=
{
    "SetTransform",
    "SetMaterial",
    "SetLight",
    "LightEnable",
    "SetRenderState",
    "SetTexture",
    "SetTextureStageState",
    "SetSamplerState",
    "SetNPatchMode",
    "SetFVF",
    "SetVertexShader",
    "SetVertexShaderConstantF",
    "SetVertexShaderConstantI",
    "SetVertexShaderConstantB",
    "SetPixelShader",
    "SetPixelShaderConstantF",
    "SetPixelShaderConstantI",
    "SetPixelShaderConstantB",
}

Definition at line 6456 of file effect.c.

Referenced by test_effect_state_manager().

test_effect_states_effect_blob

const DWORD test_effect_states_effect_blob[]

static

Definition at line 3060 of file effect.c.

Referenced by test_effect_isparameterused(), and test_effect_states().

test_effect_unsupported_shader_blob

const DWORD test_effect_unsupported_shader_blob[]

static

Initial value:

=
{
    0xfeff0901, 0x000000ac, 0x00000000, 0x00000010, 0x00000004, 0x00000020, 0x00000000, 0x00000002,
    0x00000001, 0x00000002, 0x00000007, 0x615f7376, 0x00007272, 0x00000002, 0x00000000, 0x0000004c,
    0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x00000000, 0x00000002, 0x00000069, 0x00000003,
    0x00000010, 0x00000004, 0x00000000, 0x00000000, 0x00000000, 0x00000003, 0x00003070, 0x00000006,
    0x68636574, 0x00000030, 0x00000004, 0x00000010, 0x00000004, 0x00000000, 0x00000000, 0x00000000,
    0x00000003, 0x00003070, 0x00000006, 0x68636574, 0x00000031, 0x00000002, 0x00000002, 0x00000006,
    0x00000005, 0x00000004, 0x00000018, 0x00000000, 0x00000000, 0x0000002c, 0x00000048, 0x00000000,
    0x00000000, 0x00000074, 0x00000000, 0x00000001, 0x0000006c, 0x00000000, 0x00000001, 0x00000092,
    0x00000000, 0x00000058, 0x00000054, 0x000000a0, 0x00000000, 0x00000001, 0x00000098, 0x00000000,
    0x00000001, 0x00000092, 0x00000000, 0x00000084, 0x00000080, 0x00000002, 0x00000002, 0x00000001,
    0x00000038, 0xfffe0300, 0x05000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000,
    0x0200001f, 0x80000000, 0xe00f0000, 0x02000001, 0xe00f0000, 0xa0e40000, 0x0000ffff, 0x00000002,
    0x00000038, 0xfffe03ff, 0x05000051, 0xa00f0100, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000,
    0x0200001f, 0x80000000, 0xe00f0000, 0x02000001, 0xe00f0000, 0xa0e40100, 0x0000ffff, 0x00000001,
    0x00000000, 0xffffffff, 0x00000000, 0x00000002, 0x000000e4, 0x00000008, 0x615f7376, 0x00007272,
    0x46580200, 0x0023fffe, 0x42415443, 0x0000001c, 0x00000057, 0x46580200, 0x00000001, 0x0000001c,
    0x00000100, 0x00000054, 0x00000030, 0x00000002, 0x00000001, 0x00000034, 0x00000044, 0xabab0069,
    0x00020000, 0x00010001, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
    0x4d007874, 0x6f726369, 0x74666f73, 0x29522820, 0x534c4820, 0x6853204c, 0x72656461, 0x6d6f4320,
    0x656c6970, 0x2e392072, 0x392e3932, 0x332e3235, 0x00313131, 0x0002fffe, 0x54494c43, 0x00000000,
    0x000cfffe, 0x434c5846, 0x00000001, 0x10000001, 0x00000001, 0x00000000, 0x00000002, 0x00000000,
    0x00000000, 0x00000004, 0x00000000, 0xf0f0f0f0, 0x0f0f0f0f, 0x0000ffff, 0x00000000, 0x00000000,
    0xffffffff, 0x00000000, 0x00000001, 0x0000000a, 0x615f7376, 0x315b7272, 0x0000005d,
}

Definition at line 7363 of file effect.c.

Referenced by test_effect_find_next_valid_technique(), and test_effect_unsupported_shader().

test_effect_variable_names_blob

const DWORD test_effect_variable_names_blob[]

static

Initial value:

=
{
0xfeff0901, 0x0000024c, 0x00000000, 0x00000003, 0x00000000, 0x00000024, 0x00000000, 0x00000000,
0x00000001, 0x00000001, 0x40066666, 0x00000002, 0x00000061, 0x00000003, 0x00000000, 0x0000004c,
0x00000000, 0x00000001, 0x00000001, 0x00000001, 0x00000000, 0x00000002, 0x00000062, 0x00000003,
0x00000000, 0x0000009c, 0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x00000000, 0x40400000,
0x00000003, 0x00000000, 0x00000094, 0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x00000002,
0x00000064, 0x00000002, 0x00000063, 0x00000000, 0x00000005, 0x000000dc, 0x00000000, 0x00000000,
0x00000001, 0x00000003, 0x00000000, 0x000000e4, 0x00000000, 0x00000000, 0x00000001, 0x00000001,
0x00000000, 0x00000002, 0x00000066, 0x00000002, 0x00000065, 0x00000003, 0x00000000, 0x00000134,
0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x00000000, 0x40400000, 0x00000003, 0x00000000,
0x0000012c, 0x00000000, 0x00000001, 0x00000001, 0x00000001, 0x00000002, 0x00000068, 0x00000002,
0x00000067, 0x00000003, 0x00000000, 0x000001a4, 0x00000000, 0x00000000, 0x00000001, 0x00000001,
0x00000000, 0x40800000, 0x00000000, 0x00000005, 0x00000194, 0x00000000, 0x00000001, 0x00000001,
0x00000003, 0x00000000, 0x0000019c, 0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x00000002,
0x0000006b, 0x00000002, 0x0000006a, 0x00000002, 0x00000069, 0x40a00000, 0x00000000, 0x00000005,
0x000001e4, 0x00000000, 0x00000001, 0x00000001, 0x00000003, 0x00000000, 0x000001ec, 0x00000000,
0x00000000, 0x00000001, 0x00000001, 0x00000002, 0x0000006c, 0x00000002, 0x0000006a, 0x40c00000,
0x00000000, 0x00000005, 0x0000022c, 0x00000000, 0x00000001, 0x00000001, 0x00000003, 0x00000000,
0x00000234, 0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x00000002, 0x0000006d, 0x00000002,
0x0000006a, 0x00000002, 0x00000070, 0x00000002, 0x00000074, 0x00000006, 0x00000001, 0x00000001,
0x00000001, 0x00000004, 0x00000020, 0x00000000, 0x00000000, 0x0000002c, 0x00000048, 0x00000000,
0x00000000, 0x00000054, 0x00000070, 0x00000000, 0x00000001, 0x00000078, 0x00000074, 0x000000a4,
0x000000d8, 0x00000000, 0x00000000, 0x000000ec, 0x00000108, 0x00000000, 0x00000001, 0x00000110,
0x0000010c, 0x0000013c, 0x00000158, 0x00000000, 0x00000001, 0x00000160, 0x0000015c, 0x00000244,
0x00000001, 0x00000001, 0x000001b0, 0x000001ac, 0x0000023c, 0x00000001, 0x00000000, 0x000001f8,
0x000001f4, 0x00000000, 0x00000000,
}

Definition at line 2714 of file effect.c.

Referenced by test_effect_compilation_errors(), and test_effect_variable_names().

test_two_techniques_blob

const DWORD test_two_techniques_blob[]

static

Initial value:

=
{
    0xfeff0901, 0x000000ac, 0x00000000, 0x00000000, 0x00000002, 0x00000002, 0x00000000, 0x00000000,
    0x00000000, 0x00000001, 0x00000001, 0x00000000, 0x00000002, 0x00000002, 0x00000000, 0x00000000,
    0x00000000, 0x00000001, 0x00000001, 0x00000003, 0x00003070, 0x00000006, 0x68636574, 0x00000030,
    0x00000001, 0x00000002, 0x00000002, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000001,
    0x00000001, 0x00000002, 0x00000002, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x00000001,
    0x00000003, 0x00003070, 0x00000006, 0x68636574, 0x00000031, 0x00000000, 0x00000002, 0x00000002,
    0x00000001, 0x0000004c, 0x00000000, 0x00000001, 0x00000044, 0x00000000, 0x00000002, 0x00000091,
    0x00000000, 0x00000008, 0x00000004, 0x0000000e, 0x00000000, 0x00000028, 0x00000024, 0x000000a0,
    0x00000000, 0x00000001, 0x00000098, 0x00000000, 0x00000002, 0x00000091, 0x00000000, 0x0000005c,
    0x00000058, 0x0000000e, 0x00000000, 0x0000007c, 0x00000078, 0x00000000, 0x00000000,
}

Definition at line 8332 of file effect.c.

Referenced by test_effect_find_next_valid_technique().

todo

BOOL todo[4]

Definition at line 4465 of file effect.c.

Referenced by test_effect_preshader_compare_shader_(), test_effect_preshader_compare_shader_bytecode_(), test_effect_preshader_op_results_(), test_effect_preshader_ops(), test_effect_shared_parameters_compare_vconst_(), and test_effect_shared_vs_arr_compare_helper_().

ulps

unsigned int ulps

Definition at line 4467 of file effect.c.

Referenced by _check_pixel_float4(), compare_color(), compare_double(), compare_float(), compare_matrix(), compare_plane(), compare_quaternion(), compare_vec2(), compare_vec3(), compare_vec4(), expect_color_(), expect_matrix_(), expect_plane_(), expect_quaternion_(), expect_vec2_(), expect_vec3_(), expect_vec4_(), expect_vec4_array_(), expect_vector_(), test_effect_preshader_op_results_(), and test_effect_preshader_ops().