shader.c File Reference

#include "wine/test.h"
#include "d3dx9.h"

Include dependency graph for shader.c:

Go to the source code of this file.

Classes
struct	registerset_test
struct	registerset_constants

Macros
#define	FCC_TEXT   MAKEFOURCC('T','E','X','T')
#define	FCC_CTAB   MAKEFOURCC('C','T','A','B')
#define	REGISTER_OUTPUT_SIZE   48

Enumerations
enum	Type {   T_UNKNOWN = -1, T_IGNORED_STATEMENT, T_TIDENT, T_MACRO,   T_DEFINE, T_VARIABLE, T_FUNCTION, T_FUNCTION_PTR,   T_IF, T_WHILE, T_DO, T_STRUCT,   SetFloat, SetInt, SetBool, SetIntArray,   SetBoolArray, SetFloatArray, SetMatrix, SetMatrixTranspose,   SetMatrixArray, SetMatrixTransposeArray, SetVector, SetVectorArray,   SetValue, SetMatrixPointerArray, SetMatrixTransposePointerArray }

Functions
static void	test_get_shader_size (void)
static void	test_get_shader_version (void)
static void	test_find_shader_comment (void)
static void	test_get_shader_constant_table_ex (void)
static void	test_constant_table (const char *test_name, const DWORD *ctable_fn, const D3DXCONSTANT_DESC *expecteds, UINT count)
static void	test_constant_tables (void)
static void	test_setting_basic_table (IDirect3DDevice9 *device)
static void	test_setting_matrices_table (IDirect3DDevice9 *device)
static void	test_setting_arrays_table (IDirect3DDevice9 *device)
static void	test_SetDefaults (IDirect3DDevice9 *device)
static void	test_SetValue (IDirect3DDevice9 *device)
static void	test_setting_constants (void)
static void	test_get_sampler_index (void)
static void	test_get_shader_samplers (void)
static void	test_get_shader_constant_variables (void)
static void	registerset_clear (IDirect3DDevice9 *device)
static UINT	registerset_compare (IDirect3DDevice9 *device, BOOL is_vs, D3DXREGISTER_SET regset, UINT start, UINT in_count, const DWORD *expected)
static UINT	registerset_compare_all (IDirect3DDevice9 *device, BOOL is_vs, D3DXREGISTER_SET regset, UINT start, UINT in_count, const DWORD *expected)
static HRESULT	registerset_apply (ID3DXConstantTable *ctable, IDirect3DDevice9 *device, D3DXHANDLE constant, UINT index, DWORD count, enum Type type)
static void	test_registerset (void)
static void	test_registerset_defaults (void)
static void	test_shader_semantics (void)
static void	test_fragment_linker (void)
static void	test_disassemble_shader (void)
	START_TEST (shader)

Variables
static const DWORD	shader_zero [] = {0x0}
static const DWORD	shader_invalid [] = {0xeeee0100}
static const DWORD	shader_empty [] = {0xfffe0200, 0x0000ffff}
static const DWORD	simple_fx [] = {0x46580000, 0x0002fffe, FCC_TEXT, 0x00000000, 0x0000ffff}
static const DWORD	simple_tx [] = {0x54580000, 0x0002fffe, FCC_TEXT, 0x00000000, 0x0000ffff}
static const DWORD	simple_7ffe [] = {0x7ffe0000, 0x0002fffe, FCC_TEXT, 0x00000000, 0x0000ffff}
static const DWORD	simple_7fff [] = {0x7fff0000, 0x0002fffe, FCC_TEXT, 0x00000000, 0x0000ffff}
static const DWORD	simple_vs []
static const DWORD	simple_ps []
static const DWORD	shader_with_ctab []
static const DWORD	shader_with_invalid_ctab []
static const DWORD	shader_with_ctab_constants []
static const DWORD	ctab_basic []
static const D3DXCONSTANT_DESC	ctab_basic_expected []
static const DWORD	ctab_matrices []
static const D3DXCONSTANT_DESC	ctab_matrices_expected []
static const DWORD	ctab_matrices2 []
static const D3DXCONSTANT_DESC	ctab_matrices2_expected []
static const DWORD	ctab_arrays []
static const D3DXCONSTANT_DESC	ctab_arrays_expected []
static const DWORD	ctab_with_default_values []
static const float	mat4_default_value [] = {1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16}
static const float	mat3_default_value [] = {11, 55, 99, 1313, 22, 66, 1010, 1414, 33, 77, 1111, 1515, 44, 88, 1212, 1616}
static const float	arr_default_value [] = {100, 0, 0, 0, 200, 0, 0, 0, 300, 0, 0, 0}
static const float	vec4_default_value [] = {10, 20, 30, 40}
static const float	flt_default_value [] = {9.99, 0, 0, 0}
static const D3DXCONSTANT_DESC	ctab_with_default_values_expected []
static const DWORD	ctab_samplers []
static const D3DXCONSTANT_DESC	ctab_samplers_expected []
static const DWORD	fx_shader_with_ctab []
static const DWORD	get_shader_samplers_blob []
static const DWORD	test_get_shader_constant_variables_blob []
struct {
const char *   fullname
D3DXCONSTANT_DESC   desc
UINT   ctaboffset
}	test_get_shader_constant_variables_data []
static const DWORD	registerset_test_input [][REGISTER_OUTPUT_SIZE]
static const DWORD	registerset_blob_scalar []
static const struct registerset_constants	registerset_constants_scalar_float []
static const struct registerset_test	registerset_test_scalar_float []
static const struct registerset_constants	registerset_constants_scalar_int []
static const struct registerset_test	registerset_test_scalar_int []
static const struct registerset_constants	registerset_constants_scalar_int_float []
static const struct registerset_test	registerset_test_scalar_int_float []
static const struct registerset_constants	registerset_constants_scalar_bool_float []
static const struct registerset_test	registerset_test_scalar_bool_float []
static const struct registerset_constants	registerset_constants_scalar_bool []
static const struct registerset_test	registerset_test_scalar_bool []
static const DWORD	registerset_blob_scalar_array []
static const struct registerset_constants	registerset_constants_scalar_array_float []
static const struct registerset_test	registerset_test_scalar_array_float []
static const struct registerset_constants	registerset_constants_scalar_array_int []
static const struct registerset_test	registerset_test_scalar_array_int []
static const struct registerset_constants	registerset_constants_scalar_array_bool []
static const struct registerset_test	registerset_test_scalar_array_bool []
static const struct registerset_constants	registerset_constants_scalar_array_bool_float []
static const struct registerset_test	registerset_test_scalar_array_bool_float []
static const struct registerset_constants	registerset_constants_scalar_array_int_float []
static const struct registerset_test	registerset_test_scalar_array_int_float []
static const DWORD	registerset_blob_vector []
static const struct registerset_constants	registerset_constants_vector_float []
static const struct registerset_test	registerset_test_vector_float []
static const struct registerset_constants	registerset_constants_vector_int []
static const struct registerset_test	registerset_test_vector_int []
static const struct registerset_constants	registerset_constants_vector_bool []
static const struct registerset_test	registerset_test_vector_bool []
static const struct registerset_constants	registerset_constants_vector_bool_float []
static const struct registerset_test	registerset_test_vector_bool_float []
static const struct registerset_constants	registerset_constants_vector_int_float []
static const struct registerset_test	registerset_test_vector_int_float []
static const DWORD	registerset_blob_vector_array []
static const struct registerset_constants	registerset_constants_vector_array_float []
static const struct registerset_test	registerset_test_vector_array_float []
static const struct registerset_constants	registerset_constants_vector_array_int []
static const struct registerset_test	registerset_test_vector_array_int []
static const struct registerset_constants	registerset_constants_vector_array_bool []
static const struct registerset_test	registerset_test_vector_array_bool []
static const struct registerset_constants	registerset_constants_vector_array_bool_float []
static const struct registerset_test	registerset_test_vector_array_bool_float []
static const struct registerset_constants	registerset_constants_vector_array_int_float []
static const struct registerset_test	registerset_test_vector_array_int_float []
static const DWORD	registerset_blob_column []
static const struct registerset_constants	registerset_constants_column_float []
static const struct registerset_test	registerset_test_column_float []
static const struct registerset_constants	registerset_constants_column_int []
static const struct registerset_test	registerset_test_column_int []
static const struct registerset_constants	registerset_constants_column_bool []
static const struct registerset_test	registerset_test_column_bool []
static const struct registerset_constants	registerset_constants_column_int_float []
static const struct registerset_test	registerset_test_column_int_float []
static const struct registerset_constants	registerset_constants_column_bool_float []
static const struct registerset_test	registerset_test_column_bool_float []
static const DWORD	registerset_blob_column_array []
static const struct registerset_constants	registerset_constants_column_array_float []
static const struct registerset_test	registerset_test_column_array_float []
static const struct registerset_constants	registerset_constants_column_array_int []
static const struct registerset_test	registerset_test_column_array_int []
static const struct registerset_constants	registerset_constants_column_array_bool []
static const struct registerset_test	registerset_test_column_array_bool []
static const struct registerset_constants	registerset_constants_column_array_int_float []
static const struct registerset_test	registerset_test_column_array_int_float []
static const struct registerset_constants	registerset_constants_column_array_bool_float []
static const struct registerset_test	registerset_test_column_array_bool_float []
static const DWORD	registerset_blob_row []
static const struct registerset_constants	registerset_constants_row_float []
static const struct registerset_test	registerset_test_row_float []
static const struct registerset_constants	registerset_constants_row_int []
static const struct registerset_test	registerset_test_row_int []
static const struct registerset_constants	registerset_constants_row_bool []
static const struct registerset_test	registerset_test_row_bool []
static const struct registerset_constants	registerset_constants_row_int_float []
static const struct registerset_test	registerset_test_row_int_float []
static const struct registerset_constants	registerset_constants_row_bool_float []
static const struct registerset_test	registerset_test_row_bool_float []
static const DWORD	registerset_blob_row_array []
static const struct registerset_constants	registerset_constants_row_array_float []
static const struct registerset_test	registerset_test_row_array_float []
static const struct registerset_constants	registerset_constants_row_array_int []
static const struct registerset_test	registerset_test_row_array_int []
static const struct registerset_constants	registerset_constants_row_array_bool []
static const struct registerset_test	registerset_test_row_array_bool []
static const struct registerset_constants	registerset_constants_row_array_int_float []
static const struct registerset_test	registerset_test_row_array_int_float []
static const struct registerset_constants	registerset_constants_row_array_bool_float []
static const struct registerset_test	registerset_test_row_array_bool_float []
static const DWORD	registerset_blob_struct []
static const struct registerset_constants	registerset_constants_struct_float []
static const struct registerset_test	registerset_test_struct_float []
static const struct registerset_constants	registerset_constants_struct_int []
static const struct registerset_test	registerset_test_struct_int []
static const struct registerset_constants	registerset_constants_struct_bool []
static const struct registerset_test	registerset_test_struct_bool []
static const struct registerset_constants	registerset_constants_struct_int_float []
static const struct registerset_test	registerset_test_struct_int_float []
static const struct registerset_constants	registerset_constants_struct_bool_float []
static const struct registerset_test	registerset_test_struct_bool_float []
static const DWORD	registerset_blob_struct_array []
static const struct registerset_constants	registerset_constants_struct_array_float []
static const struct registerset_test	registerset_test_struct_array_float []
static const struct registerset_constants	registerset_constants_struct_array_int []
static const struct registerset_test	registerset_test_struct_array_int []
static const struct registerset_constants	registerset_constants_struct_array_bool []
static const struct registerset_test	registerset_test_struct_array_bool []
static const struct registerset_constants	registerset_constants_struct_array_int_float []
static const struct registerset_test	registerset_test_struct_array_int_float []
static const struct registerset_constants	registerset_constants_struct_array_bool_float []
static const struct registerset_test	registerset_test_struct_array_bool_float []
static const DWORD	registerset_blob_struct_struct []
static const struct registerset_constants	registerset_constants_struct_struct_float []
static const struct registerset_test	registerset_test_struct_struct_float []
static const struct registerset_constants	registerset_constants_struct_struct_int []
static const struct registerset_test	registerset_test_struct_struct_int []
static const struct registerset_constants	registerset_constants_struct_struct_bool []
static const struct registerset_test	registerset_test_struct_struct_bool []
static const struct registerset_constants	registerset_constants_struct_struct_int_float []
static const struct registerset_test	registerset_test_struct_struct_int_float []
static const struct registerset_constants	registerset_constants_struct_struct_bool_float []
static const struct registerset_test	registerset_test_struct_struct_bool_float []
static const DWORD	registerset_blob_special_int []
static const struct registerset_constants	registerset_constants_special_int []
static const DWORD	registerset_blob_bigvec []
static const struct registerset_constants	registerset_constants_bigvec_float []
static const struct registerset_test	registerset_test_bigvec_float []
static const DWORD	registerset_blob_matrix_column_clamp []
static const struct registerset_constants	registerset_constants_matrix_column_clamp []
static const struct registerset_test	registerset_test_matrix_column_clamp []
struct {
const char *   name
const char *   var
UINT   start
D3DXREGISTER_SET   regset
const DWORD *   blob
const struct registerset_test *   tests
UINT   test_count
const struct registerset_constants *   constants
UINT   constant_count
}	registerset_data []
struct {
const char *   name
const DWORD *   blob
unsigned int   float_count
unsigned int   int_count
unsigned int   bool_count
const DWORD   floats [1024]
const DWORD   ints [256]
const DWORD   bools [16]
}	registerset_defaults_data []
static const DWORD	ps_tex []
static const DWORD	ps_texld_1_4 []
static const DWORD	ps_texld_2_0 []
static const DWORD	ps_texcoord []
static const DWORD	ps_texcrd []
static const DWORD	ps_sincos_2_0 []
static const DWORD	ps_sincos_3_0 []
static const DWORD	vs_sincos_2_0 []
static const DWORD	vs_sincos_3_0 []

Macro Definition Documentation

FCC_CTAB

#define FCC_CTAB   MAKEFOURCC('C','T','A','B')

Definition at line 24 of file shader.c.

FCC_TEXT

#define FCC_TEXT   MAKEFOURCC('T','E','X','T')

Definition at line 23 of file shader.c.

REGISTER_OUTPUT_SIZE

#define REGISTER_OUTPUT_SIZE   48

Definition at line 1964 of file shader.c.

Enumeration Type Documentation

Type

enum Type

Enumerator
T_UNKNOWN
T_IGNORED_STATEMENT
T_TIDENT
T_MACRO
T_DEFINE
T_VARIABLE
T_FUNCTION
T_FUNCTION_PTR
T_IF
T_WHILE
T_DO
T_STRUCT
SetFloat
SetInt
SetBool
SetIntArray
SetBoolArray
SetFloatArray
SetMatrix
SetMatrixTranspose
SetMatrixArray
SetMatrixTransposeArray
SetVector
SetVectorArray
SetValue
SetMatrixPointerArray
SetMatrixTransposePointerArray

Definition at line 1966 of file shader.c.

          {SetFloat, SetInt, SetBool, SetIntArray, SetBoolArray, SetFloatArray, SetMatrix,
    SetMatrixTranspose, SetMatrixArray, SetMatrixTransposeArray, SetVector, SetVectorArray,
    SetValue, SetMatrixPointerArray, SetMatrixTransposePointerArray};

Function Documentation

registerset_apply()

static HRESULT registerset_apply ( ID3DXConstantTable *  ctable, IDirect3DDevice9 *  device, D3DXHANDLE  constant, UINT  index, DWORD  count, enum Type  type  )

static

Definition at line 5964 of file shader.c.

{
    const DWORD *in = registerset_test_input[index];
    const D3DXMATRIX *inp[REGISTER_OUTPUT_SIZE / 16];
    unsigned int i;

    /* overlap, to see the difference between Array and PointerArray */
    for (i = 0; i < REGISTER_OUTPUT_SIZE / 16; i++)
    {
        inp[i] = (D3DXMATRIX *)&in[i * 15];
    }

    switch (type)
    {
        case SetInt:
            return ID3DXConstantTable_SetInt(ctable, device, constant, *((INT *)in));
        case SetFloat:
            return ID3DXConstantTable_SetFloat(ctable, device, constant, *((FLOAT *)in));
        case SetBool:
            return ID3DXConstantTable_SetBool(ctable, device, constant, *((BOOL *)in));
        case SetIntArray:
            return ID3DXConstantTable_SetIntArray(ctable, device, constant, (INT *)in, count);
        case SetBoolArray:
            return ID3DXConstantTable_SetBoolArray(ctable, device, constant, (BOOL *)in, count);
        case SetFloatArray:
            return ID3DXConstantTable_SetFloatArray(ctable, device, constant, (FLOAT *)in, count);
        case SetMatrix:
            return ID3DXConstantTable_SetMatrix(ctable, device, constant, (D3DXMATRIX *)in);
        case SetMatrixTranspose:
            return ID3DXConstantTable_SetMatrixTranspose(ctable, device, constant, (D3DXMATRIX *)in);
        case SetMatrixArray:
            return ID3DXConstantTable_SetMatrixArray(ctable, device, constant, (D3DXMATRIX *)in, count);
        case SetMatrixTransposeArray:
            return ID3DXConstantTable_SetMatrixTransposeArray(ctable, device, constant, (D3DXMATRIX *)in, count);
        case SetVector:
            return ID3DXConstantTable_SetVector(ctable, device, constant, (D3DXVECTOR4 *)in);
        case SetVectorArray:
            return ID3DXConstantTable_SetVectorArray(ctable, device, constant, (D3DXVECTOR4 *)in, count);
        case SetValue:
            return ID3DXConstantTable_SetValue(ctable, device, constant, in, count);
        case SetMatrixPointerArray:
            return ID3DXConstantTable_SetMatrixPointerArray(ctable, device, constant, inp, count);
        case SetMatrixTransposePointerArray:
            return ID3DXConstantTable_SetMatrixTransposePointerArray(ctable, device, constant, inp, count);
    }

    ok(0, "This should not happen!\n");
    return D3D_OK;
}

Referenced by test_registerset().

registerset_clear()

static void registerset_clear ( IDirect3DDevice9 *  device )

static

Definition at line 5864 of file shader.c.

{
    DWORD zero[1024];
    HRESULT hr;

    memset(zero, 0xde, 4096);

    hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, (FLOAT*)zero, 256);
    ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);

    hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, (FLOAT*)zero, 224);
    ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);

    hr = IDirect3DDevice9_SetVertexShaderConstantB(device, 0, (BOOL*)zero, 16);
    ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);

    hr = IDirect3DDevice9_SetPixelShaderConstantB(device, 0, (BOOL*)zero, 16);
    ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);

    hr = IDirect3DDevice9_SetVertexShaderConstantI(device, 0, (INT*)zero, 16);
    ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);

    hr = IDirect3DDevice9_SetPixelShaderConstantI(device, 0, (INT*)zero, 16);
    ok(hr == D3D_OK, "Clear failed, got %08x, expected %08x\n", hr, D3D_OK);
}

Referenced by test_registerset(), and test_registerset_defaults().

registerset_compare()

static UINT registerset_compare ( IDirect3DDevice9 *  device, BOOL  is_vs, D3DXREGISTER_SET  regset, UINT  start, UINT  in_count, const DWORD *  expected  )

static

Definition at line 5890 of file shader.c.

{
    DWORD ret[1024] = {0};
    HRESULT hr;
    UINT count = 1024, i, err = 0;

    memset(ret, 0xde, 4096);

    /* get shader constants */
    switch (regset)
    {
        case D3DXRS_BOOL:
            count = 16;
            if (is_vs) hr = IDirect3DDevice9_GetVertexShaderConstantB(device, 0, (BOOL*)ret, 16);
            else hr = IDirect3DDevice9_GetPixelShaderConstantB(device, 0, (BOOL*)ret, 16);
            ok(hr == D3D_OK, "Get*ShaderConstantB failed, got %08x\n", hr);
            break;

        case D3DXRS_INT4:
            count = 256;
            if (is_vs) hr = IDirect3DDevice9_GetVertexShaderConstantI(device, 0, (INT*)ret, 16);
            else hr = IDirect3DDevice9_GetPixelShaderConstantI(device, 0, (INT*)ret, 16);
            ok(hr == D3D_OK, "Get*ShaderConstantI failed, got %08x\n", hr);
            break;

        case D3DXRS_FLOAT4:
            if (is_vs) hr = IDirect3DDevice9_GetVertexShaderConstantF(device, 0, (FLOAT*)ret, 256);
            else
            {
                count = 896;
                hr = IDirect3DDevice9_GetPixelShaderConstantF(device, 0, (FLOAT*)ret, 224);
            }
            ok(hr == D3D_OK, "Get*ShaderConstantF failed, got %08x\n", hr);
            break;

        default:
            ok(0, "This should not happen!\n");
            break;
    }

    /* compare shader constants */
    for (i = 0; i < count; ++i)
    {
        DWORD value = 0xdededede;
        if (i >= start && i < start + in_count) value = expected[i - start];

        ok(ret[i] == value, "Get*ShaderConstant failed, %u got 0x%x(%f) expected 0x%x(%f)\n", i,
                ret[i], ((FLOAT *)ret)[i], value, *((FLOAT *)&value));
        if (ret[i] != value) err++;
    }

    return err;
}

Referenced by registerset_compare_all(), and test_registerset_defaults().

registerset_compare_all()

static UINT registerset_compare_all ( IDirect3DDevice9 *  device, BOOL  is_vs, D3DXREGISTER_SET  regset, UINT  start, UINT  in_count, const DWORD *  expected  )

static

Definition at line 5945 of file shader.c.

{
    D3DXREGISTER_SET regsets[] = {D3DXRS_BOOL, D3DXRS_INT4, D3DXRS_FLOAT4};
    UINT err = 0, i;

    for (i = 0; i < ARRAY_SIZE(regsets); i++)
    {
        if (regset == regsets[i])
            err += registerset_compare(device, is_vs, regset, start, in_count, expected);
        else
            err += registerset_compare(device, is_vs, regsets[i], 0, 0, NULL);

        err += registerset_compare(device, !is_vs, regsets[i], 0, 0, NULL);
    }

    return err;
}

Referenced by test_registerset().

START_TEST()

START_TEST

(

shader

)

Definition at line 6834 of file shader.c.

{
    test_get_shader_size();
    test_get_shader_version();
    test_find_shader_comment();
    test_get_shader_constant_table_ex();
    test_constant_tables();
    test_setting_constants();
    test_get_sampler_index();
    test_get_shader_samplers();
    test_get_shader_constant_variables();
    test_registerset();
    test_registerset_defaults();
    test_shader_semantics();
    test_fragment_linker();
    test_disassemble_shader();
}

test_constant_table()

static void test_constant_table ( const char *  test_name, const DWORD *  ctable_fn, const D3DXCONSTANT_DESC *  expecteds, UINT  count  )

static

Definition at line 571 of file shader.c.

{
    UINT i;
    ID3DXConstantTable *ctable;

    HRESULT res;

    /* Get the constant table from the shader itself */
    res = D3DXGetShaderConstantTable(ctable_fn, &ctable);
    ok(res == D3D_OK, "D3DXGetShaderConstantTable failed on %s: got %08x\n", test_name, res);

    for (i = 0; i < count; i++)
    {
        const D3DXCONSTANT_DESC *expected = &expecteds[i];
        D3DXHANDLE const_handle;
        D3DXCONSTANT_DESC actual;
        UINT pCount = 1;

        const_handle = ID3DXConstantTable_GetConstantByName(ctable, NULL, expected->Name);

        res = ID3DXConstantTable_GetConstantDesc(ctable, const_handle, &actual, &pCount);
        ok(SUCCEEDED(res), "%s in %s: ID3DXConstantTable_GetConstantDesc returned %08x\n", expected->Name,
                test_name, res);
        ok(pCount == 1, "%s in %s: Got more or less descriptions: %d\n", expected->Name, test_name, pCount);

        ok(strcmp(actual.Name, expected->Name) == 0,
           "%s in %s: Got different names: Got %s, expected %s\n", expected->Name,
           test_name, actual.Name, expected->Name);
        ok(actual.RegisterSet == expected->RegisterSet,
           "%s in %s: Got different register sets: Got %d, expected %d\n",
           expected->Name, test_name, actual.RegisterSet, expected->RegisterSet);
        ok(actual.RegisterIndex == expected->RegisterIndex,
           "%s in %s: Got different register indices: Got %d, expected %d\n",
           expected->Name, test_name, actual.RegisterIndex, expected->RegisterIndex);
        ok(actual.RegisterCount == expected->RegisterCount,
           "%s in %s: Got different register counts: Got %d, expected %d\n",
           expected->Name, test_name, actual.RegisterCount, expected->RegisterCount);
        ok(actual.Class == expected->Class,
           "%s in %s: Got different classes: Got %d, expected %d\n", expected->Name,
           test_name, actual.Class, expected->Class);
        ok(actual.Type == expected->Type,
           "%s in %s: Got different types: Got %d, expected %d\n", expected->Name,
           test_name, actual.Type, expected->Type);
        ok(actual.Rows == expected->Rows && actual.Columns == expected->Columns,
           "%s in %s: Got different dimensions: Got (%d, %d), expected (%d, %d)\n",
           expected->Name, test_name, actual.Rows, actual.Columns, expected->Rows,
           expected->Columns);
        ok(actual.Elements == expected->Elements,
           "%s in %s: Got different element count: Got %d, expected %d\n",
           expected->Name, test_name, actual.Elements, expected->Elements);
        ok(actual.StructMembers == expected->StructMembers,
           "%s in %s: Got different struct member count: Got %d, expected %d\n",
           expected->Name, test_name, actual.StructMembers, expected->StructMembers);
        ok(actual.Bytes == expected->Bytes,
           "%s in %s: Got different byte count: Got %d, expected %d\n",
           expected->Name, test_name, actual.Bytes, expected->Bytes);

        if (!expected->DefaultValue)
        {
            ok(actual.DefaultValue == NULL,
                "%s in %s: Got different default value: expected NULL\n",
                expected->Name, test_name);
        }
        else
        {
            ok(actual.DefaultValue != NULL,
                "%s in %s: Got different default value: expected non-NULL\n",
                expected->Name, test_name);
            ok(memcmp(actual.DefaultValue, expected->DefaultValue, expected->Bytes) == 0,
                "%s in %s: Got different default value\n", expected->Name, test_name);
        }
    }

    /* Finally, release the constant table */
    ID3DXConstantTable_Release(ctable);
}

Referenced by test_constant_tables().

test_constant_tables()

static void test_constant_tables ( void  )

static

Definition at line 649 of file shader.c.

{
    test_constant_table("test_basic", ctab_basic, ctab_basic_expected,
            ARRAY_SIZE(ctab_basic_expected));
    test_constant_table("test_matrices", ctab_matrices, ctab_matrices_expected,
            ARRAY_SIZE(ctab_matrices_expected));
    test_constant_table("test_matrices2", ctab_matrices2, ctab_matrices2_expected,
            ARRAY_SIZE(ctab_matrices2_expected));
    test_constant_table("test_arrays", ctab_arrays, ctab_arrays_expected,
            ARRAY_SIZE(ctab_arrays_expected));
    test_constant_table("test_default_values", ctab_with_default_values, ctab_with_default_values_expected,
            ARRAY_SIZE(ctab_with_default_values_expected));
    test_constant_table("test_samplers", ctab_samplers, ctab_samplers_expected,
            ARRAY_SIZE(ctab_samplers_expected));
}

Referenced by START_TEST().

test_disassemble_shader()

static void test_disassemble_shader ( void  )

static

Definition at line 6680 of file shader.c.

{
    static const char disasm_vs[] = "    vs_1_1\n"
                                    "    dcl_position v0\n"
                                    "    dp4 oPos.x, v0, c0\n"
                                    "    dp4 oPos.y, v0, c1\n"
                                    "    dp4 oPos.z, v0, c2\n"
                                    "    dp4 oPos.w, v0, c3\n";
    static const char disasm_ps[] = "    ps_1_1\n"
                                    "    def c1, 1, 0, 0, 0\n"
                                    "    tex t0\n"
                                    "    dp3 r0, c1, c0\n"
                                    "    mul r0, v0, r0\n"
                                    "    mul r0, t0, r0\n";
    static const char disasm_ps_tex[] =        "    ps_1_3\n"
                                               "    tex t0\n"
                                               "    nop\n";
    static const char disasm_ps_texld_1_4[] =  "    ps_1_4\n"
                                               "    texld t0, c0\n"
                                               "    nop\n";
    static const char disasm_ps_texld_2_0[] =  "    ps_2_0\n"
                                               "    texld t0, c0, c1\n"
                                               "    nop\n";
    static const char disasm_ps_texcoord[] =   "    ps_1_3\n"
                                               "    texcoord t0\n"
                                               "    nop\n";
    static const char disasm_ps_texcrd[] =     "    ps_1_4\n"
                                               "    texcrd t0, c0\n"
                                               "    nop\n";
    static const char disasm_ps_sincos_2_0[] = "    ps_2_0\n"
                                               "    sincos t0, c0, c1, c2\n"
                                               "    nop\n";
    static const char disasm_ps_sincos_3_0[] = "    ps_3_0\n"
                                               "    sincos t0, c0\n"
                                               "    nop\n";
    static const char disasm_vs_sincos_2_0[] = "    vs_2_0\n"
                                               "    sincos a0, c0, c1, c2\n"
                                               "    nop\n";
    static const char disasm_vs_sincos_3_0[] = "    vs_3_0\n"
                                               "    sincos a0, c0\n"
                                               "    nop\n";
    ID3DXBuffer *disassembly;
    HRESULT ret;
    char *ptr;

    /* Check wrong parameters */
    ret = D3DXDisassembleShader(NULL, FALSE, NULL, NULL);
    ok(ret == D3DERR_INVALIDCALL, "Returned %#x, expected %#x\n", ret, D3DERR_INVALIDCALL);
    ret = D3DXDisassembleShader(NULL, FALSE, NULL, &disassembly);
    ok(ret == D3DERR_INVALIDCALL, "Returned %#x, expected %#x\n", ret, D3DERR_INVALIDCALL);
    ret = D3DXDisassembleShader(simple_vs, FALSE, NULL, NULL);
    ok(ret == D3DERR_INVALIDCALL, "Returned %#x, expected %#x\n", ret, D3DERR_INVALIDCALL);

    /* Test with vertex shader */
    disassembly = (void *)0xdeadbeef;
    ret = D3DXDisassembleShader(simple_vs, FALSE, NULL, &disassembly);
    ok(ret == D3D_OK, "Failed with %#x\n", ret);
    ptr = ID3DXBuffer_GetBufferPointer(disassembly);
    ok(!memcmp(ptr, disasm_vs, sizeof(disasm_vs) - 1), /* compare beginning */
       "Returned '%s', expected '%s'\n", ptr, disasm_vs);
    ID3DXBuffer_Release(disassembly);

    /* Test with pixel shader */
    disassembly = (void *)0xdeadbeef;
    ret = D3DXDisassembleShader(simple_ps, FALSE, NULL, &disassembly);
    ok(ret == D3D_OK, "Failed with %#x\n", ret);
    ptr = ID3DXBuffer_GetBufferPointer(disassembly);
    ok(!memcmp(ptr, disasm_ps, sizeof(disasm_ps) - 1), /* compare beginning */
       "Returned '%s', expected '%s'\n", ptr, disasm_ps);
    ID3DXBuffer_Release(disassembly);

    /* Test tex instruction with pixel shader 1.3 */
    disassembly = (void *)0xdeadbeef;
    ret = D3DXDisassembleShader(ps_tex, FALSE, NULL, &disassembly);
    ok(ret == D3D_OK, "Failed with %#x\n", ret);
    ptr = ID3DXBuffer_GetBufferPointer(disassembly);
    ok(!memcmp(ptr, disasm_ps_tex, sizeof(disasm_ps_tex) - 1), /* compare beginning */
       "Returned '%s', expected '%s'\n", ptr, disasm_ps_tex);
    ID3DXBuffer_Release(disassembly);

    /* Test texld instruction with pixel shader 1.4 */
    disassembly = (void *)0xdeadbeef;
    ret = D3DXDisassembleShader(ps_texld_1_4, FALSE, NULL, &disassembly);
    ok(ret == D3D_OK, "Failed with %#x\n", ret);
    ptr = ID3DXBuffer_GetBufferPointer(disassembly);
    ok(!memcmp(ptr, disasm_ps_texld_1_4, sizeof(disasm_ps_texld_1_4) - 1), /* compare beginning */
       "Returned '%s', expected '%s'\n", ptr, disasm_ps_texld_1_4);
    ID3DXBuffer_Release(disassembly);

    /* Test texld instruction with pixel shader 2.0 */
    disassembly = (void *)0xdeadbeef;
    ret = D3DXDisassembleShader(ps_texld_2_0, FALSE, NULL, &disassembly);
    ok(ret == D3D_OK, "Failed with %#x\n", ret);
    ptr = ID3DXBuffer_GetBufferPointer(disassembly);
    ok(!memcmp(ptr, disasm_ps_texld_2_0, sizeof(disasm_ps_texld_2_0) - 1), /* compare beginning */
       "Returned '%s', expected '%s'\n", ptr, disasm_ps_texld_2_0);
    ID3DXBuffer_Release(disassembly);

    /* Test texcoord instruction with pixel shader 1.3 */
    disassembly = (void *)0xdeadbeef;
    ret = D3DXDisassembleShader(ps_texcoord, FALSE, NULL, &disassembly);
    ok(ret == D3D_OK, "Failed with %#x\n", ret);
    ptr = ID3DXBuffer_GetBufferPointer(disassembly);
    ok(!memcmp(ptr, disasm_ps_texcoord, sizeof(disasm_ps_texcoord) - 1), /* compare beginning */
       "Returned '%s', expected '%s'\n", ptr, disasm_ps_texcoord);
    ID3DXBuffer_Release(disassembly);

    /* Test texcrd instruction with pixel shader 1.4 */
    disassembly = (void *)0xdeadbeef;
    ret = D3DXDisassembleShader(ps_texcrd, FALSE, NULL, &disassembly);
    ok(ret == D3D_OK, "Failed with %#x\n", ret);
    ptr = ID3DXBuffer_GetBufferPointer(disassembly);
    ok(!memcmp(ptr, disasm_ps_texcrd, sizeof(disasm_ps_texcrd) - 1), /* compare beginning */
       "Returned '%s', expected '%s'\n", ptr, disasm_ps_texcrd);
    ID3DXBuffer_Release(disassembly);

    /* Test sincos instruction pixel shader 2.0 */
    disassembly = (void *)0xdeadbeef;
    ret = D3DXDisassembleShader(ps_sincos_2_0, FALSE, NULL, &disassembly);
    ok(ret == D3D_OK, "Failed with %#x\n", ret);
    ptr = ID3DXBuffer_GetBufferPointer(disassembly);
    ok(!memcmp(ptr, disasm_ps_sincos_2_0, sizeof(disasm_ps_sincos_2_0) - 1), /* compare beginning */
       "Returned '%s', expected '%s'\n", ptr, disasm_ps_sincos_2_0);
    ID3DXBuffer_Release(disassembly);

    /* Test sincos instruction with pixel shader 3.0 */
    disassembly = (void *)0xdeadbeef;
    ret = D3DXDisassembleShader(ps_sincos_3_0, FALSE, NULL, &disassembly);
    ok(ret == D3D_OK, "Failed with %#x\n", ret);
    ptr = ID3DXBuffer_GetBufferPointer(disassembly);
    ok(!memcmp(ptr, disasm_ps_sincos_3_0, sizeof(disasm_ps_sincos_3_0) - 1), /* compare beginning */
       "Returned '%s', expected '%s'\n", ptr, disasm_ps_sincos_3_0);
    ID3DXBuffer_Release(disassembly);

    /* Test sincos instruction with pixel shader 2.0 */
    disassembly = (void *)0xdeadbeef;
    ret = D3DXDisassembleShader(vs_sincos_2_0, FALSE, NULL, &disassembly);
    ok(ret == D3D_OK, "Failed with %#x\n", ret);
    ptr = ID3DXBuffer_GetBufferPointer(disassembly);
    ok(!memcmp(ptr, disasm_vs_sincos_2_0, sizeof(disasm_vs_sincos_2_0) - 1), /* compare beginning */
       "Returned '%s', expected '%s'\n", ptr, disasm_vs_sincos_2_0);
    ID3DXBuffer_Release(disassembly);

    /* Test sincos instruction with pixel shader 3.0 */
    disassembly = (void *)0xdeadbeef;
    ret = D3DXDisassembleShader(vs_sincos_3_0, FALSE, NULL, &disassembly);
    ok(ret == D3D_OK, "Failed with %#x\n", ret);
    ptr = ID3DXBuffer_GetBufferPointer(disassembly);
    ok(!memcmp(ptr, disasm_vs_sincos_3_0, sizeof(disasm_vs_sincos_3_0) - 1), /* compare beginning */
       "Returned '%s', expected '%s'\n", ptr, disasm_vs_sincos_3_0);
    ID3DXBuffer_Release(disassembly);

}

Referenced by START_TEST().

test_find_shader_comment()

static void test_find_shader_comment ( void  )

static

Definition at line 334 of file shader.c.

{
    const void *data = (void *)0xdeadbeef;
    HRESULT hr;
    UINT size = 100;

    hr = D3DXFindShaderComment(NULL, MAKEFOURCC('C','T','A','B'), &data, &size);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
    ok(!data, "Got %p, expected NULL\n", data);
    ok(!size, "Got %u, expected 0\n", size);

    hr = D3DXFindShaderComment(shader_with_ctab, MAKEFOURCC('C','T','A','B'), NULL, &size);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
    ok(size == 28, "Got %u, expected 28\n", size);

    hr = D3DXFindShaderComment(shader_with_ctab, MAKEFOURCC('C','T','A','B'), &data, NULL);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
    ok(data == shader_with_ctab + 6, "Got result %p, expected %p\n", data, shader_with_ctab + 6);

    hr = D3DXFindShaderComment(shader_with_ctab, 0, &data, &size);
    ok(hr == S_FALSE, "Got result %x, expected 1 (S_FALSE)\n", hr);
    ok(!data, "Got %p, expected NULL\n", data);
    ok(!size, "Got %u, expected 0\n", size);

    hr = D3DXFindShaderComment(shader_with_ctab, MAKEFOURCC('X','X','X','X'), &data, &size);
    ok(hr == S_FALSE, "Got result %x, expected 1 (S_FALSE)\n", hr);
    ok(!data, "Got %p, expected NULL\n", data);
    ok(!size, "Got %u, expected 0\n", size);

    hr = D3DXFindShaderComment(shader_with_ctab, MAKEFOURCC('C','T','A','B'), &data, &size);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
    ok(data == shader_with_ctab + 6, "Got result %p, expected %p\n", data, shader_with_ctab + 6);
    ok(size == 28, "Got result %u, expected 28\n", size);

    hr = D3DXFindShaderComment(shader_zero, MAKEFOURCC('C','T','A','B'), &data, &size);
    ok(hr == D3DXERR_INVALIDDATA, "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, D3DXERR_INVALIDDATA);
    ok(!data, "Got %p, expected NULL\n", data);
    ok(!size, "Got %u, expected 0\n", size);

    hr = D3DXFindShaderComment(shader_invalid, MAKEFOURCC('C','T','A','B'), &data, &size);
    ok(hr == D3DXERR_INVALIDDATA, "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, D3DXERR_INVALIDDATA);
    ok(!data, "Got %p, expected NULL\n", data);
    ok(!size, "Got %u, expected 0\n", size);

    hr = D3DXFindShaderComment(shader_empty, MAKEFOURCC('C','T','A','B'), &data, &size);
    ok(hr == S_FALSE, "Got result %x, expected %x (S_FALSE)\n", hr, S_FALSE);
    ok(!data, "Got %p, expected NULL\n", data);
    ok(!size, "Got %u, expected 0\n", size);

    hr = D3DXFindShaderComment(simple_fx, FCC_TEXT, &data, &size);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
    ok(data == simple_fx + 3, "Got result %p, expected %p\n", data, simple_fx + 3);
    ok(size == 4, "Got result %u, expected 4\n", size);

    hr = D3DXFindShaderComment(simple_tx, FCC_TEXT, &data, &size);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
    ok(data == simple_tx + 3, "Got result %p, expected %p\n", data, simple_tx + 3);
    ok(size == 4, "Got result %u, expected 4\n", size);

    hr = D3DXFindShaderComment(simple_7ffe, FCC_TEXT, &data, &size);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
    ok(data == simple_7ffe + 3, "Got result %p, expected %p\n", data, simple_7ffe + 3);
    ok(size == 4, "Got result %u, expected 4\n", size);

    hr = D3DXFindShaderComment(simple_7fff, FCC_TEXT, &data, &size);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
    ok(data == simple_7fff + 3, "Got result %p, expected %p\n", data, simple_7fff + 3);
    ok(size == 4, "Got result %u, expected 4\n", size);
}

Referenced by START_TEST().

test_fragment_linker()

static void test_fragment_linker ( void  )

static

Definition at line 6578 of file shader.c.

{
    ID3DXFragmentLinker *linker;
    D3DPRESENT_PARAMETERS d3dpp;
    IDirect3DDevice9 *device;
    IDirect3D9 *d3d;
    ULONG refcount;
    HWND window;
    HRESULT hr;

    window = CreateWindowA("static", "d3dx9_test", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, NULL, NULL, NULL, NULL);
    if (!(d3d = Direct3DCreate9(D3D_SDK_VERSION)))
    {
        skip("Failed to create a D3D object.\n");
        DestroyWindow(window);
        return;
    }

    ZeroMemory(&d3dpp, sizeof(d3dpp));
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
            D3DCREATE_MIXED_VERTEXPROCESSING, &d3dpp, &device);
    if (FAILED(hr))
    {
        skip("Failed to create a D3D device, hr %#x.\n", hr);
        IDirect3D9_Release(d3d);
        DestroyWindow(window);
        return;
    }

    hr = D3DXCreateFragmentLinker(device, 1024, &linker);
    ok(hr == D3D_OK, "Unexpected hr %#x.\n", hr);
    ok(!!linker, "Unexpected linker %p.\n", linker);
    linker->lpVtbl->Release(linker);

    hr = D3DXCreateFragmentLinkerEx(device, 1024, 0, &linker);
    ok(hr == D3D_OK, "Unexpected hr %#x.\n", hr);
    ok(!!linker, "Unexpected linker %p.\n", linker);
    linker->lpVtbl->Release(linker);

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

Referenced by START_TEST().

test_get_sampler_index()

static void test_get_sampler_index ( void  )

static

Definition at line 1499 of file shader.c.

{
    ID3DXConstantTable *ctable;

    HRESULT res;
    UINT index;

    ULONG refcnt;

    res = D3DXGetShaderConstantTable(ctab_samplers, &ctable);
    ok(res == D3D_OK, "D3DXGetShaderConstantTable failed on ctab_samplers: got %08x\n", res);

    index = ID3DXConstantTable_GetSamplerIndex(ctable, "sampler1");
    ok(index == 0, "ID3DXConstantTable_GetSamplerIndex returned wrong index: Got %d, expected 0\n", index);

    index = ID3DXConstantTable_GetSamplerIndex(ctable, "sampler2");
    ok(index == 3, "ID3DXConstantTable_GetSamplerIndex returned wrong index: Got %d, expected 3\n", index);

    index = ID3DXConstantTable_GetSamplerIndex(ctable, "nonexistent");
    ok(index == -1, "ID3DXConstantTable_GetSamplerIndex found nonexistent sampler: Got %d\n",
            index);

    index = ID3DXConstantTable_GetSamplerIndex(ctable, "notsampler");
    ok(index == -1, "ID3DXConstantTable_GetSamplerIndex succeeded on non-sampler constant: Got %d\n",
            index);

    refcnt = ID3DXConstantTable_Release(ctable);
    ok(refcnt == 0, "The ID3DXConstantTable reference count was %u, should be 0\n", refcnt);
}

Referenced by START_TEST().

test_get_shader_constant_table_ex()

static void test_get_shader_constant_table_ex ( void  )

static

Definition at line 404 of file shader.c.

{
    ID3DXConstantTable *constant_table;
    HRESULT hr;
    void *data;
    DWORD size;
    D3DXCONSTANTTABLE_DESC desc;

    constant_table = (ID3DXConstantTable *)0xdeadbeef;
    hr = D3DXGetShaderConstantTableEx(NULL, 0, &constant_table);
    ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
    ok(constant_table == NULL, "D3DXGetShaderConstantTableEx() failed, got %p\n", constant_table);

    constant_table = (ID3DXConstantTable *)0xdeadbeef;
    hr = D3DXGetShaderConstantTableEx(shader_zero, 0, &constant_table);
    ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);
    ok(constant_table == NULL, "D3DXGetShaderConstantTableEx() failed, got %p\n", constant_table);

    constant_table = (ID3DXConstantTable *)0xdeadbeef;
    hr = D3DXGetShaderConstantTableEx(shader_invalid, 0, &constant_table);
    ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);
    ok(constant_table == NULL, "D3DXGetShaderConstantTableEx() failed, got %p\n", constant_table);

    constant_table = (ID3DXConstantTable *)0xdeadbeef;
    hr = D3DXGetShaderConstantTableEx(shader_empty, 0, &constant_table);
    ok(hr == D3DXERR_INVALIDDATA, "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, D3DXERR_INVALIDDATA);
    ok(constant_table == NULL, "D3DXGetShaderConstantTableEx() failed, got %p\n", constant_table);

    /* No CTAB data */
    constant_table = (ID3DXConstantTable *)0xdeadbeef;
    hr = D3DXGetShaderConstantTableEx(simple_ps, 0, &constant_table);
    ok(hr == D3DXERR_INVALIDDATA, "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, D3DXERR_INVALIDDATA);
    ok(constant_table == NULL, "D3DXGetShaderConstantTableEx() failed, got %p\n", constant_table);

    /* With invalid CTAB data */
    hr = D3DXGetShaderConstantTableEx(shader_with_invalid_ctab, 0, &constant_table);
    ok(hr == D3DXERR_INVALIDDATA || broken(hr == D3D_OK), /* winxp 64-bit, w2k3 64-bit */
       "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, D3DXERR_INVALIDDATA);
    if (constant_table) ID3DXConstantTable_Release(constant_table);

    hr = D3DXGetShaderConstantTableEx(simple_fx, 0, &constant_table);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK).\n", hr);
    ok(!constant_table, "D3DXGetShaderConstantTableEx() returned a non-NULL constant table.\n");

    hr = D3DXGetShaderConstantTableEx(simple_tx, 0, &constant_table);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK).\n", hr);
    ok(!constant_table, "D3DXGetShaderConstantTableEx() returned a non-NULL constant table.\n");

    hr = D3DXGetShaderConstantTableEx(shader_with_ctab, 0, &constant_table);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
    ok(constant_table != NULL, "D3DXGetShaderConstantTableEx() failed, got NULL\n");

    if (constant_table)
    {
        size = ID3DXConstantTable_GetBufferSize(constant_table);
        ok(size == 28, "Got result %x, expected 28\n", size);

        data = ID3DXConstantTable_GetBufferPointer(constant_table);
        ok(!memcmp(data, shader_with_ctab + 6, size), "Retrieved wrong CTAB data\n");

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

        hr = ID3DXConstantTable_GetDesc(constant_table, &desc);
        ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
        ok(desc.Creator == (const char *)data + 0x10, "Got result %p, expected %p\n",
                desc.Creator, (const char *)data + 0x10);
        ok(desc.Version == D3DVS_VERSION(3, 0), "Got result %x, expected %x\n", desc.Version, D3DVS_VERSION(3, 0));
        ok(desc.Constants == 0, "Got result %x, expected 0\n", desc.Constants);

        ID3DXConstantTable_Release(constant_table);
    }

    hr = D3DXGetShaderConstantTableEx(shader_with_ctab_constants, 0, &constant_table);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
    ok(constant_table != NULL, "D3DXGetShaderConstantTableEx() failed, got NULL\n");

    if (constant_table)
    {
        D3DXHANDLE constant;
        D3DXCONSTANT_DESC constant_desc;
        D3DXCONSTANT_DESC constant_desc_save;
        UINT nb;

        /* Test GetDesc */
        hr = ID3DXConstantTable_GetDesc(constant_table, &desc);
        ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
        ok(!strcmp(desc.Creator, "Wine project"), "Got result '%s', expected 'Wine project'\n", desc.Creator);
        ok(desc.Version == D3DVS_VERSION(3, 0), "Got result %x, expected %x\n", desc.Version, D3DVS_VERSION(3, 0));
        ok(desc.Constants == 3, "Got result %x, expected 3\n", desc.Constants);

        /* Test GetConstant */
        constant = ID3DXConstantTable_GetConstant(constant_table, NULL, 0);
        ok(constant != NULL, "No constant found\n");
        hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, &constant_desc, &nb);
        ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
        ok(!strcmp(constant_desc.Name, "Constant1"), "Got result '%s', expected 'Constant1'\n",
            constant_desc.Name);
        ok(constant_desc.Class == D3DXPC_VECTOR, "Got result %x, expected %u (D3DXPC_VECTOR)\n",
            constant_desc.Class, D3DXPC_VECTOR);
        ok(constant_desc.Type == D3DXPT_FLOAT, "Got result %x, expected %u (D3DXPT_FLOAT)\n",
            constant_desc.Type, D3DXPT_FLOAT);
        ok(constant_desc.Rows == 1, "Got result %x, expected 1\n", constant_desc.Rows);
        ok(constant_desc.Columns == 4, "Got result %x, expected 4\n", constant_desc.Columns);

        constant = ID3DXConstantTable_GetConstant(constant_table, NULL, 1);
        ok(constant != NULL, "No constant found\n");
        hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, &constant_desc, &nb);
        ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
        ok(!strcmp(constant_desc.Name, "Constant2"), "Got result '%s', expected 'Constant2'\n",
            constant_desc.Name);
        ok(constant_desc.Class == D3DXPC_MATRIX_COLUMNS, "Got result %x, expected %u (D3DXPC_MATRIX_COLUMNS)\n",
            constant_desc.Class, D3DXPC_MATRIX_COLUMNS);
        ok(constant_desc.Type == D3DXPT_FLOAT, "Got result %x, expected %u (D3DXPT_FLOAT)\n",
            constant_desc.Type, D3DXPT_FLOAT);
        ok(constant_desc.Rows == 4, "Got result %x, expected 1\n", constant_desc.Rows);
        ok(constant_desc.Columns == 4, "Got result %x, expected 4\n", constant_desc.Columns);

        constant = ID3DXConstantTable_GetConstant(constant_table, NULL, 2);
        ok(constant != NULL, "No constant found\n");
        hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, &constant_desc, &nb);
        ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
        ok(!strcmp(constant_desc.Name, "Constant3"), "Got result '%s', expected 'Constant3'\n",
            constant_desc.Name);
        ok(constant_desc.Class == D3DXPC_MATRIX_COLUMNS, "Got result %x, expected %u (D3DXPC_MATRIX_COLUMNS)\n",
            constant_desc.Class, D3DXPC_MATRIX_COLUMNS);
        ok(constant_desc.Type == D3DXPT_FLOAT, "Got result %x, expected %u (D3DXPT_FLOAT)\n",
            constant_desc.Type, D3DXPT_FLOAT);
        ok(constant_desc.Rows == 4, "Got result %x, expected 1\n", constant_desc.Rows);
        ok(constant_desc.Columns == 4, "Got result %x, expected 4\n", constant_desc.Columns);
        constant_desc_save = constant_desc; /* For GetConstantDesc test */

        constant = ID3DXConstantTable_GetConstant(constant_table, NULL, 3);
        ok(constant == NULL, "Got result %p, expected NULL\n", constant);

        /* Test GetConstantByName */
        constant = ID3DXConstantTable_GetConstantByName(constant_table, NULL, "Constant unknown");
        ok(constant == NULL, "Got result %p, expected NULL\n", constant);
        constant = ID3DXConstantTable_GetConstantByName(constant_table, NULL, "Constant3");
        ok(constant != NULL, "No constant found\n");
        hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, &constant_desc, &nb);
        ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
        ok(!memcmp(&constant_desc, &constant_desc_save, sizeof(D3DXCONSTANT_DESC)), "Got different constant data\n");

        /* Test GetConstantDesc */
        constant = ID3DXConstantTable_GetConstant(constant_table, NULL, 0);
        ok(constant != NULL, "No constant found\n");
        hr = ID3DXConstantTable_GetConstantDesc(constant_table, NULL, &constant_desc, &nb);
        ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
        hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, NULL, &nb);
        ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
        hr = ID3DXConstantTable_GetConstantDesc(constant_table, constant, &constant_desc, NULL);
        ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
        hr = ID3DXConstantTable_GetConstantDesc(constant_table, "Constant unknown", &constant_desc, &nb);
        ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
        hr = ID3DXConstantTable_GetConstantDesc(constant_table, "Constant3", &constant_desc, &nb);
        ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
        ok(!memcmp(&constant_desc, &constant_desc_save, sizeof(D3DXCONSTANT_DESC)), "Got different constant data\n");

        ID3DXConstantTable_Release(constant_table);
    }

    hr = D3DXGetShaderConstantTableEx(fx_shader_with_ctab, 0, &constant_table);
    ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK).\n", hr);
    ok(!constant_table, "D3DXGetShaderConstantTableEx() returned a non-NULL constant table.\n");
}

Referenced by START_TEST().

test_get_shader_constant_variables()

static void test_get_shader_constant_variables ( void  )

static

Definition at line 1830 of file shader.c.

{
    ID3DXConstantTable *ctable;
    HRESULT hr;
    ULONG count;
    UINT i;
    UINT nr = 1;
    D3DXHANDLE constant, element;
    D3DXCONSTANT_DESC desc;
    DWORD *ctab;

    hr = D3DXGetShaderConstantTable(test_get_shader_constant_variables_blob, &ctable);
    ok(hr == D3D_OK, "D3DXGetShaderConstantTable failed, got %08x, expected %08x\n", hr, D3D_OK);

    ctab = ID3DXConstantTable_GetBufferPointer(ctable);
    ok(ctab[0] == test_get_shader_constant_variables_blob[3], "ID3DXConstantTable_GetBufferPointer failed\n");

    for (i = 0; i < ARRAY_SIZE(test_get_shader_constant_variables_data); ++i)
    {
        const char *fullname = test_get_shader_constant_variables_data[i].fullname;
        const D3DXCONSTANT_DESC *expected_desc = &test_get_shader_constant_variables_data[i].desc;
        UINT ctaboffset = test_get_shader_constant_variables_data[i].ctaboffset;

        constant = ID3DXConstantTable_GetConstantByName(ctable, NULL, fullname);
        ok(constant != NULL, "GetConstantByName \"%s\" failed\n", fullname);

        hr = ID3DXConstantTable_GetConstantDesc(ctable, constant, &desc, &nr);
        ok(hr == D3D_OK, "GetConstantDesc \"%s\" failed, got %08x, expected %08x\n", fullname, hr, D3D_OK);

        ok(!strcmp(expected_desc->Name, desc.Name), "GetConstantDesc \"%s\" failed, got \"%s\", expected \"%s\"\n",
                fullname, desc.Name, expected_desc->Name);
        ok(expected_desc->RegisterSet == desc.RegisterSet, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
                fullname, desc.RegisterSet, expected_desc->RegisterSet);
        ok(expected_desc->RegisterIndex == desc.RegisterIndex, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                fullname, desc.RegisterIndex, expected_desc->RegisterIndex);
        ok(expected_desc->RegisterCount == desc.RegisterCount, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                fullname, desc.RegisterCount, expected_desc->RegisterCount);
        ok(expected_desc->Class == desc.Class, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                fullname, desc.Class, expected_desc->Class);
        ok(expected_desc->Type == desc.Type, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
                fullname, desc.Type, expected_desc->Type);
        ok(expected_desc->Rows == desc.Rows, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
                fullname, desc.Rows, expected_desc->Rows);
        ok(expected_desc->Columns == desc.Columns, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                fullname, desc.Columns, expected_desc->Columns);
        ok(expected_desc->Elements == desc.Elements, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                fullname, desc.Elements, expected_desc->Elements);
        ok(expected_desc->StructMembers == desc.StructMembers, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                fullname, desc.StructMembers, expected_desc->StructMembers);
        ok(expected_desc->Bytes == desc.Bytes, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                fullname, desc.Bytes, expected_desc->Bytes);
        ok(ctaboffset == (DWORD *)desc.DefaultValue - ctab, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
           fullname, (UINT)((DWORD *)desc.DefaultValue - ctab), ctaboffset);
    }

    element = ID3DXConstantTable_GetConstantElement(ctable, NULL, 0);
    ok(element == NULL, "GetConstantElement failed\n");

    constant = ID3DXConstantTable_GetConstantByName(ctable, NULL, "i");
    ok(constant != NULL, "GetConstantByName failed\n");

    element = ID3DXConstantTable_GetConstantByName(ctable, NULL, "i[0]");
    ok(constant == element, "GetConstantByName failed, got %p, expected %p\n", element, constant);

    element = ID3DXConstantTable_GetConstantElement(ctable, "i", 0);
    ok(element == constant, "GetConstantElement failed, got %p, expected %p\n", element, constant);

    constant = ID3DXConstantTable_GetConstantByName(ctable, NULL, "f");
    ok(constant != NULL, "GetConstantByName failed\n");

    element = ID3DXConstantTable_GetConstant(ctable, NULL, 0);
    ok(element == constant, "GetConstant failed, got %p, expected %p\n", element, constant);

    element = ID3DXConstantTable_GetConstant(ctable, "invalid", 0);
    ok(element == NULL, "GetConstant failed\n");

    element = ID3DXConstantTable_GetConstant(ctable, "f", 0);
    ok(element == NULL, "GetConstant failed\n");

    element = ID3DXConstantTable_GetConstantByName(ctable, NULL, "f[0]");
    ok(constant == element, "GetConstantByName failed, got %p, expected %p\n", element, constant);

    element = ID3DXConstantTable_GetConstantByName(ctable, NULL, "f[1]");
    ok(NULL == element, "GetConstantByName failed\n");

    element = ID3DXConstantTable_GetConstantByName(ctable, NULL, "f[0][0]");
    ok(constant == element, "GetConstantByName failed, got %p, expected %p\n", element, constant);

    element = ID3DXConstantTable_GetConstantByName(ctable, NULL, "f.");
    ok(element == NULL, "GetConstantByName failed\n");

    element = ID3DXConstantTable_GetConstantElement(ctable, "f", 0);
    ok(element == constant, "GetConstantElement failed, got %p, expected %p\n", element, constant);

    element = ID3DXConstantTable_GetConstantElement(ctable, "f", 1);
    ok(element == NULL, "GetConstantElement failed\n");

    constant = ID3DXConstantTable_GetConstantByName(ctable, NULL, "f_2[0]");
    ok(constant != NULL, "GetConstantByName failed\n");

    element = ID3DXConstantTable_GetConstantByName(ctable, NULL, "f_2");
    ok(element != constant, "GetConstantByName failed, got %p, expected %p\n", element, constant);

    element = ID3DXConstantTable_GetConstantElement(ctable, "f_2", 0);
    ok(element == constant, "GetConstantElement failed, got %p, expected %p\n", element, constant);

    constant = ID3DXConstantTable_GetConstantByName(ctable, NULL, "f_2[1]");
    ok(constant != NULL, "GetConstantByName failed\n");

    element = ID3DXConstantTable_GetConstantElement(ctable, "f_2", 1);
    ok(element == constant, "GetConstantElement failed, got %p, expected %p\n", element, constant);

    constant = ID3DXConstantTable_GetConstantByName(ctable, NULL, "s_2[0].f");
    ok(constant != NULL, "GetConstantByName failed\n");

    element = ID3DXConstantTable_GetConstant(ctable, "s_2[0]", 0);
    ok(element == constant, "GetConstant failed, got %p, expected %p\n", element, constant);

    element = ID3DXConstantTable_GetConstantByName(ctable, "s_2[0]", "f");
    ok(element == constant, "GetConstantByName failed, got %p, expected %p\n", element, constant);

    element = ID3DXConstantTable_GetConstantByName(ctable, "s_2[0]", "invalid");
    ok(element == NULL, "GetConstantByName failed\n");

    constant = ID3DXConstantTable_GetConstantByName(ctable, NULL, "s_2[0]");
    ok(constant != NULL, "GetConstantByName failed\n");

    element = ID3DXConstantTable_GetConstantElement(ctable, "s_2[0]", 0);
    ok(constant == element, "GetConstantByName failed, got %p, expected %p\n", element, constant);

    count = ID3DXConstantTable_Release(ctable);
    ok(count == 0, "Release failed, got %u, expected %u\n", count, 0);
}

Referenced by START_TEST().

test_get_shader_samplers()

static void test_get_shader_samplers ( void  )

static

Definition at line 1592 of file shader.c.

{
    const char *samplers[16] = {NULL}; /* maximum number of sampler registers v/ps 3.0 = 16 */
    const char *sampler_orig;
    UINT count = 2;
    HRESULT hr;

if (0)
{
    /* crashes if bytecode is NULL */
    hr = D3DXGetShaderSamplers(NULL, NULL, &count);
    ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
}

    hr = D3DXGetShaderSamplers(get_shader_samplers_blob, NULL, NULL);
    ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);

    samplers[5] = "dummy";

    hr = D3DXGetShaderSamplers(get_shader_samplers_blob, samplers, NULL);
    ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);

    /* check that sampler points to shader blob */
    sampler_orig = (const char *)&get_shader_samplers_blob[0x2e];
    ok(sampler_orig == samplers[0], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[0], sampler_orig);

    sampler_orig = (const char *)&get_shader_samplers_blob[0x33];
    ok(sampler_orig == samplers[1], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[1], sampler_orig);

    sampler_orig = (const char *)&get_shader_samplers_blob[0x38];
    ok(sampler_orig == samplers[2], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[2], sampler_orig);

    sampler_orig = (const char *)&get_shader_samplers_blob[0x3d];
    ok(sampler_orig == samplers[3], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[3], sampler_orig);

    sampler_orig = (const char *)&get_shader_samplers_blob[0x42];
    ok(sampler_orig == samplers[4], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[4], sampler_orig);

    ok(!strcmp(samplers[5], "dummy"), "D3DXGetShaderSamplers failed, got \"%s\", expected \"%s\"\n", samplers[5], "dummy");

    /* reset samplers */
    memset(samplers, 0, sizeof(samplers));
    samplers[5] = "dummy";

    hr = D3DXGetShaderSamplers(get_shader_samplers_blob, NULL, &count);
    ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
    ok(count == 5, "D3DXGetShaderSamplers failed, got %u, expected %u\n", count, 5);

    hr = D3DXGetShaderSamplers(get_shader_samplers_blob, samplers, &count);
    ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
    ok(count == 5, "D3DXGetShaderSamplers failed, got %u, expected %u\n", count, 5);

    /* check that sampler points to shader blob */
    sampler_orig = (const char *)&get_shader_samplers_blob[0x2e];
    ok(sampler_orig == samplers[0], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[0], sampler_orig);

    sampler_orig = (const char *)&get_shader_samplers_blob[0x33];
    ok(sampler_orig == samplers[1], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[1], sampler_orig);

    sampler_orig = (const char *)&get_shader_samplers_blob[0x38];
    ok(sampler_orig == samplers[2], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[2], sampler_orig);

    sampler_orig = (const char *)&get_shader_samplers_blob[0x3d];
    ok(sampler_orig == samplers[3], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[3], sampler_orig);

    sampler_orig = (const char *)&get_shader_samplers_blob[0x42];
    ok(sampler_orig == samplers[4], "D3DXGetShaderSamplers failed, got %p, expected %p\n", samplers[4], sampler_orig);

    ok(!strcmp(samplers[5], "dummy"), "D3DXGetShaderSamplers failed, got \"%s\", expected \"%s\"\n", samplers[5], "dummy");

    /* check without ctab */
    hr = D3DXGetShaderSamplers(simple_vs, samplers, &count);
    ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
    ok(count == 0, "D3DXGetShaderSamplers failed, got %u, expected %u\n", count, 0);

    /* check invalid ctab */
    hr = D3DXGetShaderSamplers(shader_with_invalid_ctab, samplers, &count);
    ok(hr == D3D_OK, "D3DXGetShaderSamplers failed, got %x, expected %x\n", hr, D3D_OK);
    ok(count == 0, "D3DXGetShaderSamplers failed, got %u, expected %u\n", count, 0);
}

Referenced by START_TEST().

test_get_shader_size()

static void test_get_shader_size ( void  )

static

Definition at line 302 of file shader.c.

{
    UINT shader_size, expected;

    shader_size = D3DXGetShaderSize(simple_vs);
    expected = sizeof(simple_vs);
    ok(shader_size == expected, "Got shader size %u, expected %u\n", shader_size, expected);

    shader_size = D3DXGetShaderSize(simple_ps);
    expected = sizeof(simple_ps);
    ok(shader_size == expected, "Got shader size %u, expected %u\n", shader_size, expected);

    shader_size = D3DXGetShaderSize(NULL);
    ok(shader_size == 0, "Got shader size %u, expected 0\n", shader_size);
}

Referenced by START_TEST().

test_get_shader_version()

static void test_get_shader_version ( void  )

static

Definition at line 318 of file shader.c.

{
    DWORD shader_version;

    shader_version = D3DXGetShaderVersion(simple_vs);
    ok(shader_version == D3DVS_VERSION(1, 1), "Got shader version 0x%08x, expected 0x%08x\n",
            shader_version, D3DVS_VERSION(1, 1));

    shader_version = D3DXGetShaderVersion(simple_ps);
    ok(shader_version == D3DPS_VERSION(1, 1), "Got shader version 0x%08x, expected 0x%08x\n",
            shader_version, D3DPS_VERSION(1, 1));

    shader_version = D3DXGetShaderVersion(NULL);
    ok(shader_version == 0, "Got shader version 0x%08x, expected 0\n", shader_version);
}

Referenced by START_TEST().

test_registerset()

static void test_registerset ( void  )

static

Definition at line 6015 of file shader.c.

{
    UINT k;
    HWND wnd;
    IDirect3D9 *d3d;
    IDirect3DDevice9 *device;
    D3DPRESENT_PARAMETERS d3dpp;
    HRESULT hr;
    ULONG count;
    D3DCAPS9 caps;

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

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

    hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
    ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
    if (caps.VertexShaderVersion < D3DVS_VERSION(3, 0)
            || caps.PixelShaderVersion < D3DPS_VERSION(3, 0))
    {
        skip("Skipping: Test requires VS >= 3 and PS >= 3.\n");
        IDirect3DDevice9_Release(device);
        IDirect3D9_Release(d3d);
        DestroyWindow(wnd);
        return;
    }

    for (k = 0; k < ARRAY_SIZE(registerset_data); ++k)
    {
        const char *tablename = registerset_data[k].name;
        const char *name = registerset_data[k].var;
        ID3DXConstantTable *ctable;
        D3DXCONSTANTTABLE_DESC tdesc;
        D3DXHANDLE constant;
        UINT i;
        BOOL is_vs;
        DWORD *ctab;

        hr = D3DXGetShaderConstantTable(registerset_data[k].blob, &ctable);
        ok(hr == D3D_OK, "D3DXGetShaderConstantTable \"%s\" failed, got %08x, expected %08x\n", tablename, hr, D3D_OK);

        hr = ID3DXConstantTable_GetDesc(ctable, &tdesc);
        ok(hr == D3D_OK, "GetDesc \"%s\" failed, got %08x, expected %08x\n", tablename, hr, D3D_OK);

        ctab = ID3DXConstantTable_GetBufferPointer(ctable);
        ok(ctab[0] == registerset_data[k].blob[3], "ID3DXConstantTable_GetBufferPointer failed\n");

        is_vs = (tdesc.Version & 0xFFFF0000) == 0xFFFE0000;

        for (i = 0; i < registerset_data[k].constant_count; ++i)
        {
            const char *fullname = registerset_data[k].constants[i].fullname;
            const D3DXCONSTANT_DESC *expected_desc = &registerset_data[k].constants[i].desc;
            D3DXCONSTANT_DESC desc;
            UINT nr = 0;
            UINT ctaboffset = registerset_data[k].constants[i].ctaboffset;

            constant = ID3DXConstantTable_GetConstantByName(ctable, NULL, fullname);
            ok(constant != NULL, "GetConstantByName \"%s\" failed\n", fullname);

            hr = ID3DXConstantTable_GetConstantDesc(ctable, constant, &desc, &nr);
            ok(hr == D3D_OK, "GetConstantDesc \"%s\" failed, got %08x, expected %08x\n", fullname, hr, D3D_OK);

            ok(!strcmp(expected_desc->Name, desc.Name), "GetConstantDesc \"%s\" failed, got \"%s\", expected \"%s\"\n",
                    fullname, desc.Name, expected_desc->Name);
            ok(expected_desc->RegisterSet == desc.RegisterSet, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
                    fullname, desc.RegisterSet, expected_desc->RegisterSet);
            ok(expected_desc->RegisterIndex == desc.RegisterIndex,
                    "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                    fullname, desc.RegisterIndex, expected_desc->RegisterIndex);
            ok(expected_desc->RegisterCount == desc.RegisterCount,
                    "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                    fullname, desc.RegisterCount, expected_desc->RegisterCount);
            ok(expected_desc->Class == desc.Class, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                    fullname, desc.Class, expected_desc->Class);
            ok(expected_desc->Type == desc.Type, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
                    fullname, desc.Type, expected_desc->Type);
            ok(expected_desc->Rows == desc.Rows, "GetConstantDesc \"%s\" failed, got %#x, expected %#x\n",
                    fullname, desc.Rows, expected_desc->Rows);
            ok(expected_desc->Columns == desc.Columns, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                    fullname, desc.Columns, expected_desc->Columns);
            ok(expected_desc->Elements == desc.Elements, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                    fullname, desc.Elements, expected_desc->Elements);
            ok(expected_desc->StructMembers == desc.StructMembers,
                    "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                    fullname, desc.StructMembers, expected_desc->StructMembers);
            ok(expected_desc->Bytes == desc.Bytes, "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                    fullname, desc.Bytes, expected_desc->Bytes);
            if (ctaboffset)
            {
                ok(ctaboffset == (DWORD *)desc.DefaultValue - ctab,
                        "GetConstantDesc \"%s\" failed, got %u, expected %u\n",
                        fullname, (UINT)((DWORD *)desc.DefaultValue - ctab), ctaboffset);
            }
        }

        constant = ID3DXConstantTable_GetConstantByName(ctable, NULL, name);
        ok(constant != NULL, "GetConstantByName \"%s\" \"%s\" failed\n", tablename, name);

        for (i = 0; i < registerset_data[k].test_count; ++i)
        {
            const struct registerset_test *test = &registerset_data[k].tests[i];
            UINT ret;

            registerset_clear(device);

            hr = registerset_apply(ctable, device, constant, test->in_index, test->in_count_min, test->type);
            ok(hr == D3D_OK, "Set* \"%s\" index %u, count %u failed, got %x, expected %x\n", tablename, i,
                    test->in_count_min, hr, D3D_OK);

            ret = registerset_compare_all(device, is_vs, registerset_data[k].regset,
                    registerset_data[k].start, test->out_count, test->out);
            ok(ret == 0, "Get*ShaderConstant \"%s\" index %u, count %u failed\n", tablename, i, test->in_count_min);

            if (test->in_count_max > test->in_count_min)
            {
                registerset_clear(device);

                hr = registerset_apply(ctable, device, constant, test->in_index, test->in_count_max, test->type);
                ok(hr == D3D_OK, "Set* \"%s\" index %u, count %u failed, got %x, expected %x\n", tablename, i,
                        test->in_count_max, hr, D3D_OK);

                ret = registerset_compare_all(device, is_vs, registerset_data[k].regset,
                        registerset_data[k].start, test->out_count, test->out);
                ok(ret == 0, "Get*ShaderConstant \"%s\" index %u, count %u failed\n", tablename, i, test->in_count_max);
            }
        }

        count = ID3DXConstantTable_Release(ctable);
        ok(count == 0, "Release \"%s\" failed, got %u, expected %u\n", tablename, count, 0);
    }

    /* Release resources */
    count = IDirect3DDevice9_Release(device);
    ok(count == 0, "The Direct3D device reference count was %u, should be 0\n", count);

    count = IDirect3D9_Release(d3d);
    ok(count == 0, "The Direct3D object reference count was %u, should be 0\n", count);

    if (wnd) DestroyWindow(wnd);
}

Referenced by START_TEST().

test_registerset_defaults()

static void test_registerset_defaults ( void  )

static

Definition at line 6320 of file shader.c.

{
    UINT k;
    HWND wnd;
    IDirect3D9 *d3d;
    IDirect3DDevice9 *device;
    D3DPRESENT_PARAMETERS d3dpp;
    HRESULT hr;
    ULONG count;
    D3DCAPS9 caps;

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

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

    hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
    ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr);
    if (caps.VertexShaderVersion < D3DVS_VERSION(3, 0)
            || caps.PixelShaderVersion < D3DPS_VERSION(3, 0))
    {
        skip("Skipping: Test requires VS >= 3 and PS >= 3.\n");
        IDirect3DDevice9_Release(device);
        IDirect3D9_Release(d3d);
        DestroyWindow(wnd);
        return;
    }

    for (k = 0; k < ARRAY_SIZE(registerset_defaults_data); ++k)
    {
        const char *tablename = registerset_defaults_data[k].name;
        ID3DXConstantTable *ctable;
        D3DXCONSTANTTABLE_DESC tdesc;
        BOOL is_vs;
        UINT ret;

        hr = D3DXGetShaderConstantTable(registerset_defaults_data[k].blob, &ctable);
        ok(hr == D3D_OK, "D3DXGetShaderConstantTable \"%s\" failed, got %08x, expected %08x\n", tablename, hr, D3D_OK);

        hr = ID3DXConstantTable_GetDesc(ctable, &tdesc);
        ok(hr == D3D_OK, "GetDesc \"%s\" failed, got %08x, expected %08x\n", tablename, hr, D3D_OK);

        is_vs = (tdesc.Version & 0xFFFF0000) == 0xFFFE0000;

        registerset_clear(device);

        hr = ID3DXConstantTable_SetDefaults(ctable, device);
        ok(hr == D3D_OK, "SetDefaults \"%s\" failed, got %08x, expected %08x\n", tablename, hr, D3D_OK);

        ret = registerset_compare(device, is_vs, D3DXRS_FLOAT4, 0, registerset_defaults_data[k].float_count,
                registerset_defaults_data[k].floats);
        ok(ret == 0, "Get*ShaderConstantF \"%s\" failed\n", tablename);

        ret = registerset_compare(device, is_vs, D3DXRS_INT4, 0, registerset_defaults_data[k].int_count,
                registerset_defaults_data[k].ints);
        ok(ret == 0, "Get*ShaderConstantI \"%s\" failed\n", tablename);

        ret = registerset_compare(device, is_vs, D3DXRS_BOOL, 0, registerset_defaults_data[k].bool_count,
                registerset_defaults_data[k].bools);
        ok(ret == 0, "Get*ShaderConstantB \"%s\" failed\n", tablename);

        count = ID3DXConstantTable_Release(ctable);
        ok(count == 0, "Release \"%s\" failed, got %u, expected %u\n", tablename, count, 0);
    }

    /* Release resources */
    count = IDirect3DDevice9_Release(device);
    ok(count == 0, "The Direct3D device reference count was %u, should be 0\n", count);

    count = IDirect3D9_Release(d3d);
    ok(count == 0, "The Direct3D object reference count was %u, should be 0\n", count);

    if (wnd) DestroyWindow(wnd);
}

Referenced by START_TEST().

test_SetDefaults()

static void test_SetDefaults ( IDirect3DDevice9 *  device )

static

Definition at line 1198 of file shader.c.

{
    static const D3DXMATRIX mvp = {{{
        0.51f, 0.62f, 0.80f, 0.78f,
        0.23f, 0.95f, 0.37f, 0.48f,
        0.10f, 0.58f, 0.90f, 0.25f,
        0.89f, 0.41f, 0.93f, 0.27f}}};
    static const D3DXVECTOR4 f4 = {0.2f, 0.4f, 0.8f, 1.2f};

    float out[16];

    HRESULT res;
    ID3DXConstantTable *ctable;

    res = D3DXGetShaderConstantTable(ctab_basic, &ctable);
    ok(res == D3D_OK, "D3DXGetShaderConstantTable failed: got %08x\n", res);

    res = ID3DXConstantTable_SetVector(ctable, device, "f4", &f4);
    ok(res == D3D_OK, "ID3DXConstantTable_SetVector failed: got %08x\n", res);

    res = ID3DXConstantTable_SetMatrix(ctable, device, "mvp", &mvp);
    ok(res == D3D_OK, "ID3DXConstantTable_SetMatrix failed: got %08x\n", res);

    res = ID3DXConstantTable_SetDefaults(ctable, device);
    ok(res == D3D_OK, "ID3dXConstantTable_SetDefaults failed: got %08x\n", res);

    /* SetDefaults doesn't change constants without default values */
    IDirect3DDevice9_GetVertexShaderConstantF(device, 0, out, 4);
    ok(out[0] == S(U(mvp))._11 && out[4] == S(U(mvp))._12 && out[8] == S(U(mvp))._13 && out[12] == S(U(mvp))._14,
            "The first row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[0], out[4], out[8], out[12], S(U(mvp))._11, S(U(mvp))._12, S(U(mvp))._13, S(U(mvp))._14);
    ok(out[1] == S(U(mvp))._21 && out[5] == S(U(mvp))._22 && out[9] == S(U(mvp))._23 && out[13] == S(U(mvp))._24,
            "The second row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[1], out[5], out[9], out[13], S(U(mvp))._21, S(U(mvp))._22, S(U(mvp))._23, S(U(mvp))._24);
    ok(out[2] == S(U(mvp))._31 && out[6] == S(U(mvp))._32 && out[10] == S(U(mvp))._33 && out[14] == S(U(mvp))._34,
            "The third row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[2], out[6], out[10], out[14], S(U(mvp))._31, S(U(mvp))._32, S(U(mvp))._33, S(U(mvp))._34);
    ok(out[3] == S(U(mvp))._41 && out[7] == S(U(mvp))._42 && out[11] == S(U(mvp))._43 && out[15] == S(U(mvp))._44,
            "The fourth row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[3], out[7], out[11], out[15], S(U(mvp))._41, S(U(mvp))._42, S(U(mvp))._43, S(U(mvp))._44);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 7, out, 1);
    ok(memcmp(out, &f4, sizeof(f4)) == 0,
            "The variable f4 was not set correctly, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[0], out[1], out[2], out[3], f4.x, f4.y, f4.z, f4.w);

    ID3DXConstantTable_Release(ctable);

    res = D3DXGetShaderConstantTable(ctab_with_default_values, &ctable);
    ok(res == D3D_OK, "D3DXGetShaderConstantTable failed: got %08x\n", res);

    res = ID3DXConstantTable_SetDefaults(ctable, device);
    ok(res == D3D_OK, "ID3DXConstantTable_SetDefaults failed: got %08x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 0, out, 4);
    ok(memcmp(out, mat4_default_value, sizeof(mat4_default_value)) == 0,
            "The variable mat4 was not set correctly to default value\n");

    IDirect3DDevice9_GetVertexShaderConstantF(device, 4, out, 4);
    ok(memcmp(out, mat3_default_value, sizeof(mat3_default_value)) == 0,
            "The variable mat3 was not set correctly to default value\n");

    IDirect3DDevice9_GetVertexShaderConstantF(device, 8, out, 3);
    ok(memcmp(out, arr_default_value, sizeof(arr_default_value)) == 0,
        "The variable array was not set correctly to default value\n");

    IDirect3DDevice9_GetVertexShaderConstantF(device, 11, out, 1);
    ok(memcmp(out, vec4_default_value, sizeof(vec4_default_value)) == 0,
        "The variable vec4 was not set correctly to default value\n");

    IDirect3DDevice9_GetVertexShaderConstantF(device, 12, out, 1);
    ok(memcmp(out, flt_default_value, sizeof(flt_default_value)) == 0,
        "The variable flt was not set correctly to default value\n");

    ID3DXConstantTable_Release(ctable);
}

Referenced by test_setting_constants().

test_setting_arrays_table()

static void test_setting_arrays_table ( IDirect3DDevice9 *  device )

static

Definition at line 1086 of file shader.c.

{
    static const float farray[8] = {
        0.005f, 0.745f, 0.973f, 0.264f,
        0.010f, 0.020f, 0.030f, 0.040f};
    static const D3DXMATRIX fmtxarray[2] = {
        {{{0.001f, 0.002f, 0.003f, 0.004f,
           0.005f, 0.006f, 0.007f, 0.008f,
           0.009f, 0.010f, 0.011f, 0.012f,
           0.013f, 0.014f, 0.015f, 0.016f}}},
        {{{0.010f, 0.020f, 0.030f, 0.040f,
           0.050f, 0.060f, 0.070f, 0.080f,
           0.090f, 0.100f, 0.110f, 0.120f,
           0.130f, 0.140f, 0.150f, 0.160f}}}};
    static const int iarray[4] = {1, 2, 3, 4};
    static const D3DXVECTOR4 fvecarray[2] = {
        {0.745f, 0.997f, 0.353f, 0.237f},
        {0.060f, 0.455f, 0.333f, 0.983f}};
    static BOOL barray[4] = {FALSE, 100, TRUE, TRUE};

    ID3DXConstantTable *ctable;

    HRESULT res;
    float out[32];
    ULONG refcnt;

    /* Clear registers */
    memset(out, 0, sizeof(out));
    IDirect3DDevice9_SetVertexShaderConstantF(device,  8, out, 4);
    IDirect3DDevice9_SetVertexShaderConstantF(device, 12, out, 4);

    /* Get the constant table from the shader */
    res = D3DXGetShaderConstantTable(ctab_arrays, &ctable);
    ok(res == D3D_OK, "D3DXGetShaderConstantTable failed: got 0x%08x\n", res);

    /* Set constants */

    /* Make sure that we cannot set registers that do not belong to this constant */
    res = ID3DXConstantTable_SetFloatArray(ctable, device, "farray", farray, 8);
    ok(res == D3D_OK, "ID3DXConstantTable_SetFloatArray failed: got 0x%08x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 8, out, 8);
    ok(out[0] == farray[0] && out[4] == farray[1] && out[8] == farray[2] && out[12] == farray[3],
            "The in-bounds elements of the array were not set, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[0], out[4], out[8], out[12], farray[0], farray[1], farray[2], farray[3]);
    ok(out[16] == 0.0f && out[20] == 0.0f && out[24] == 0.0f && out[28] == 0.0f,
            "The excess elements of the array were set, out={%f, %f, %f, %f}, should be all 0.0f\n",
            out[16], out[20], out[24], out[28]);

    /* ivecarray takes up only 1 register, but a matrix takes up 4, so no elements should be set */
    res = ID3DXConstantTable_SetMatrix(ctable, device, "ivecarray", &fmtxarray[0]);
    ok(res == D3D_OK, "ID3DXConstantTable_SetMatrix failed: got 0x%08x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 18, out, 4);
    ok(out[0] == 0.0f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
       "The array was set, out={%f, %f, %f, %f}, should be all 0.0f\n", out[0], out[1], out[2], out[3]);

    /* Try setting an integer array to an array declared as a float array */
    res = ID3DXConstantTable_SetIntArray(ctable, device, "farray", iarray, 4);
    ok(res == D3D_OK, "ID3DXConstantTable_SetIntArray failed: got 0x%08x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 8, out, 4);
    ok(out[0] == iarray[0] && out[4] == iarray[1] && out[8] == iarray[2] && out[12] == iarray[3],
           "SetIntArray did not properly set a float array: out={%f, %f, %f, %f}, should be {%d, %d, %d, %d}\n",
            out[0], out[4], out[8], out[12], iarray[0], iarray[1], iarray[2], iarray[3]);

    res = ID3DXConstantTable_SetFloatArray(ctable, device, "farray", farray, 4);
    ok(res == D3D_OK, "ID3DXConstantTable_SetFloatArray failed: got x0%08x\n", res);

    res = ID3DXConstantTable_SetVectorArray(ctable, device, "fvecarray", fvecarray, 2);
    ok(res == D3D_OK, "ID3DXConstantTable_SetVectorArray failed: got 0x%08x\n", res);

    res = ID3DXConstantTable_SetMatrixArray(ctable, device, "fmtxarray", fmtxarray, 2);
    ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixArray failed: got 0x%08x\n", res);

    res = ID3DXConstantTable_SetBoolArray(ctable, device, "barray", barray, 2);
    ok(res == D3D_OK, "ID3DXConstantTable_SetBoolArray failed: got 0x%08x\n", res);

    /* Read back constants */
    IDirect3DDevice9_GetVertexShaderConstantF(device, 8, out, 4);
    ok(out[0] == farray[0] && out[4] == farray[1] && out[8] == farray[2] && out[12] == farray[3],
            "The variable farray was not set correctly, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[0], out[4], out[8], out[12], farray[0], farray[1], farray[2], farray[3]);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 12, out, 2);
    ok(out[0] == fvecarray[0].x && out[1] == fvecarray[0].y && out[2] == fvecarray[0].z && out[3] == fvecarray[0].w &&
            out[4] == fvecarray[1].x && out[5] == fvecarray[1].y && out[6] == fvecarray[1].z && out[7] == fvecarray[1].w,
            "The variable fvecarray was not set correctly, out={{%f, %f, %f, %f}, {%f, %f, %f, %f}}, should be "
            "{{%f, %f, %f, %f}, {%f, %f, %f, %f}}\n", out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7],
            fvecarray[0].x, fvecarray[0].y, fvecarray[0].z, fvecarray[0].w, fvecarray[1].x, fvecarray[1].y,
            fvecarray[1].z, fvecarray[1].w);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 14, out, 2);
    ok(out[0] == 0.0f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f
            && out[4] == 1.0f && out[5] == 0.0f && out[6] == 0.0f && out[7] == 0.0f,
            "The variable barray was not set correctly, out={%f, %f %f, %f; %f, %f, %f, %f}, should be {%f, %f, %f, %f; %f, %f, %f, %f}\n",
            out[0], out[1], out[2], out[3], out[4], out[5], out[6], out[7],
            0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 0, out, 8);
    /* Just check a few elements in each matrix to make sure fmtxarray was set row-major */
    ok(out[0] == S(U(fmtxarray[0]))._11 && out[1] == S(U(fmtxarray[0]))._12 && out[2] == S(U(fmtxarray[0]))._13 && out[3] == S(U(fmtxarray[0]))._14,
           "The variable fmtxarray was not set row-major, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
           out[0], out[1], out[2], out[3], S(U(fmtxarray[0]))._11, S(U(fmtxarray[0]))._12, S(U(fmtxarray[0]))._13, S(U(fmtxarray[0]))._14);
    ok(out[16] == S(U(fmtxarray[1]))._11 && out[17] == S(U(fmtxarray[1]))._12 && out[18] == S(U(fmtxarray[1]))._13 && out[19] == S(U(fmtxarray[1]))._14,
           "The variable fmtxarray was not set row-major, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
           out[16], out[17], out[18], out[19], S(U(fmtxarray[1]))._11, S(U(fmtxarray[1]))._12, S(U(fmtxarray[1]))._13, S(U(fmtxarray[1]))._14);

    refcnt = ID3DXConstantTable_Release(ctable);
    ok(refcnt == 0, "The constant table reference count was %u, should be 0\n", refcnt);
}

Referenced by test_setting_constants().

test_setting_basic_table()

static void test_setting_basic_table ( IDirect3DDevice9 *  device )

static

Definition at line 665 of file shader.c.

{
    static const D3DXMATRIX mvp = {{{
        0.514f, 0.626f, 0.804f, 0.786f,
        0.238f, 0.956f, 0.374f, 0.483f,
        0.109f, 0.586f, 0.900f, 0.255f,
        0.898f, 0.411f, 0.932f, 0.275f}}};
    static const D3DXVECTOR4 f4 = {0.350f, 0.526f, 0.925f, 0.021f};
    static const float f = 0.12543f;
    static const int i = 321;
    static const D3DXMATRIX *matrix_pointer[] = {&mvp};

    ID3DXConstantTable *ctable;

    HRESULT res;
    float out[16];
    ULONG refcnt;

    /* Get the constant table from the shader itself */
    res = D3DXGetShaderConstantTable(ctab_basic, &ctable);
    ok(res == D3D_OK, "D3DXGetShaderConstantTable failed: got 0x%08x\n", res);

    /* Set constants */
    res = ID3DXConstantTable_SetMatrix(ctable, device, "mvp", &mvp);
    ok(res == D3D_OK, "ID3DXConstantTable_SetMatrix failed on variable mvp: got 0x%08x\n", res);

    res = ID3DXConstantTable_SetInt(ctable, device, "i", i + 1);
    ok(res == D3D_OK, "ID3DXConstantTable_SetInt failed on variable i: got 0x%08x\n", res);

    /* Check that setting i again will overwrite the previous value */
    res = ID3DXConstantTable_SetInt(ctable, device, "i", i);
    ok(res == D3D_OK, "ID3DXConstantTable_SetInt failed on variable i: got 0x%08x\n", res);

    res = ID3DXConstantTable_SetFloat(ctable, device, "f", f);
    ok(res == D3D_OK, "ID3DXConstantTable_SetFloat failed on variable f: got 0x%08x\n", res);

    res = ID3DXConstantTable_SetVector(ctable, device, "f4", &f4);
    ok(res == D3D_OK, "ID3DXConstantTable_SetVector failed on variable f4: got 0x%08x\n", res);

    /* Get constants back and validate */
    IDirect3DDevice9_GetVertexShaderConstantF(device, 0, out, 4);
    ok(out[0] == S(U(mvp))._11 && out[4] == S(U(mvp))._12 && out[8] == S(U(mvp))._13 && out[12] == S(U(mvp))._14,
            "The first row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[0], out[4], out[8], out[12], S(U(mvp))._11, S(U(mvp))._12, S(U(mvp))._13, S(U(mvp))._14);
    ok(out[1] == S(U(mvp))._21 && out[5] == S(U(mvp))._22 && out[9] == S(U(mvp))._23 && out[13] == S(U(mvp))._24,
            "The second row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[1], out[5], out[9], out[13], S(U(mvp))._21, S(U(mvp))._22, S(U(mvp))._23, S(U(mvp))._24);
    ok(out[2] == S(U(mvp))._31 && out[6] == S(U(mvp))._32 && out[10] == S(U(mvp))._33 && out[14] == S(U(mvp))._34,
            "The third row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[2], out[6], out[10], out[14], S(U(mvp))._31, S(U(mvp))._32, S(U(mvp))._33, S(U(mvp))._34);
    ok(out[3] == S(U(mvp))._41 && out[7] == S(U(mvp))._42 && out[11] == S(U(mvp))._43 && out[15] == S(U(mvp))._44,
            "The fourth row of mvp was not set correctly, got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[3], out[7], out[11], out[15], S(U(mvp))._41, S(U(mvp))._42, S(U(mvp))._43, S(U(mvp))._44);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 4, out, 1);
    ok(out[0] == (float)i && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
            "The variable i was not set correctly, out={%f, %f, %f, %f}, should be {%d, 0.0, 0.0, 0.0}\n",
            out[0], out[1], out[2], out[3], i);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 6, out, 1);
    ok(out[0] == f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
            "The variable f was not set correctly, out={%f, %f, %f, %f}, should be {%f, 0.0, 0.0, 0.0}\n",
            out[0], out[1], out[2], out[3], f);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 7, out, 1);
    ok(memcmp(out, &f4, sizeof(f4)) == 0,
            "The variable f4 was not set correctly, out={%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[0], out[1], out[2], out[3], f4.x, f4.y, f4.z, f4.w);

    /* Finally test using a set* function for one type to set a variable of another type (should succeed) */
    res = ID3DXConstantTable_SetVector(ctable, device, "f", &f4);
    ok(res == D3D_OK, "ID3DXConstantTable_SetVector failed on variable f: 0x%08x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 6, out, 1);
    ok(out[0] == f4.x && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
            "The variable f was not set correctly by ID3DXConstantTable_SetVector, got %f, should be %f\n",
            out[0], f4.x);

    memset(out, 0, sizeof(out));
    IDirect3DDevice9_SetVertexShaderConstantF(device, 6, out, 1);
    res = ID3DXConstantTable_SetMatrix(ctable, device, "f", &mvp);
    ok(res == D3D_OK, "ID3DXConstantTable_SetMatrix failed on variable f: 0x%08x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 6, out, 1);
    ok(out[0] == S(U(mvp))._11 && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
            "The variable f was not set correctly by ID3DXConstantTable_SetMatrix, got %f, should be %f\n",
            out[0], S(U(mvp))._11);

    /* Clear registers */
    memset(out, 0, sizeof(out));
    IDirect3DDevice9_SetVertexShaderConstantF(device, 0, out, 4);
    IDirect3DDevice9_SetVertexShaderConstantF(device, 6, out, 1);
    IDirect3DDevice9_SetVertexShaderConstantF(device, 7, out, 1);

    /* SetVector shouldn't change the value of a matrix constant */
    res = ID3DXConstantTable_SetVector(ctable, device, "mvp", &f4);
    ok(res == D3D_OK, "ID3DXConstantTable_SetVector failed on variable f: 0x%08x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 0, out, 4);
    ok(out[0] == 0.0f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f
            && out[4] == 0.0f && out[5] == 0.0f && out[6] == 0.0f && out[7] == 0.0f
            && out[8] == 0.0f && out[9] == 0.0f && out[10] == 0.0f && out[11] == 0.0f
            && out[12] == 0.0f && out[13] == 0.0f && out[14] == 0.0f && out[15] == 0.0f,
            "The variable mvp was not set correctly by ID3DXConstantTable_SetVector, "
            "got {%f, %f, %f, %f; %f, %f, %f, %f; %f, %f, %f %f; %f, %f, %f, %f}, "
            "should be all 0.0f\n",
            out[0], out[1], out[2], out[3],
            out[4], out[5], out[6], out[7],
            out[8], out[9], out[10], out[11],
            out[12], out[13], out[14], out[15]);

    res = ID3DXConstantTable_SetFloat(ctable, device, "mvp", f);
    ok(res == D3D_OK, "ID3DXConstantTable_SetFloat failed on variable mvp: 0x%08x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 0, out, 4);
    ok(out[0] == 0.0f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f
            && out[4] == 0.0f && out[5] == 0.0f && out[6] == 0.0f && out[7] == 0.0f
            && out[8] == 0.0f && out[9] == 0.0f && out[10] == 0.0f && out[11] == 0.0f
            && out[12] == 0.0f && out[13] == 0.0f && out[14] == 0.0f && out[15] == 0.0f,
            "The variable mvp was not set correctly by ID3DXConstantTable_SetFloat, "
            "got {%f, %f, %f, %f; %f, %f, %f, %f; %f, %f, %f %f; %f, %f, %f, %f}, "
            "should be all 0.0f\n",
            out[0], out[1], out[2], out[3],
            out[4], out[5], out[6], out[7],
            out[8], out[9], out[10], out[11],
            out[12], out[13], out[14], out[15]);

    res = ID3DXConstantTable_SetFloat(ctable, device, "f4", f);
    ok(res == D3D_OK, "ID3DXConstantTable_SetFloat failed on variable f4: 0x%08x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 7, out, 1);
    ok(out[0] == 0.0f && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
            "The variable f4 was not set correctly by ID3DXConstantTable_SetFloat, "
            "got {%f, %f, %f, %f}, should be all 0.0f\n",
            out[0], out[1], out[2], out[3]);

    res = ID3DXConstantTable_SetMatrixTranspose(ctable, device, "f", &mvp);
    ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixTranspose failed on variable f: 0x%08x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 6, out, 1);
    ok(out[0] == S(U(mvp))._11 && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
            "The variable f was not set correctly by ID3DXConstantTable_SetMatrixTranspose, got %f, should be %f\n",
            out[0], S(U(mvp))._11);

    res = ID3DXConstantTable_SetMatrixTranspose(ctable, device, "f4", &mvp);
    ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixTranspose failed on variable f4: 0x%08x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 7, out, 1);
    ok(out[0] == S(U(mvp))._11 && out[1] == S(U(mvp))._21 && out[2] == S(U(mvp))._31 && out[3] == S(U(mvp))._41,
            "The variable f4 was not set correctly by ID3DXConstantTable_SetMatrixTranspose, "
            "got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[0], out[1], out[2], out[3],
            S(U(mvp))._11, S(U(mvp))._21, S(U(mvp))._31, S(U(mvp))._41);

    memset(out, 0, sizeof(out));
    IDirect3DDevice9_SetVertexShaderConstantF(device, 6, out, 1);
    res = ID3DXConstantTable_SetMatrixPointerArray(ctable, device, "f", matrix_pointer, 1);
    ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixPointerArray failed on variable f: got %#x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 6, out, 1);
    ok(out[0] == S(U(mvp))._11 && out[1] == 0.0f && out[2] == 0.0f && out[3] == 0.0f,
            "The variable f was not set correctly by ID3DXConstantTable_SetMatrixPointerArray, "
            "got %f, should be %f\n",
            out[0], S(U(mvp))._11);

    res = ID3DXConstantTable_SetMatrixPointerArray(ctable, device, "f4", matrix_pointer, 1);
    ok(res == D3D_OK, "ID3DXConstantTable_SetMatrixPointerArray failed on variable f4: got %#x\n", res);

    IDirect3DDevice9_GetVertexShaderConstantF(device, 7, out, 1);
    ok(out[0] == S(U(mvp))._11 && out[1] == S(U(mvp))._12 && out[2] == S(U(mvp))._13 && out[3] == S(U(mvp))._14,
            "The variable f4 was not set correctly by ID3DXConstantTable_SetMatrixPointerArray, "
            "got {%f, %f, %f, %f}, should be {%f, %f, %f, %f}\n",
            out[0], out[1], out[2], out[3],
            S(U(mvp))._11, S(U(mvp))._12, S(U(mvp))._13, S(U(mvp))._14);

    memset(out, 0, sizeof(out));
    IDirect3DDevice9_SetVertexShaderConstantF(device, 6, out, 1);
    res =