git.oblomov.eu Git - wine/blob - dlls/d3dx9_36/tests/effect.c

   1 /*
   2  * Copyright 2010 Christian Costa
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20 #include "initguid.h"
  21 #include <limits.h>
  22 #include "wine/test.h"
  23 #include "d3dx9.h"
  24
  25 /* helper functions */
  26 static BOOL compare_float(FLOAT f, FLOAT g, UINT ulps)
  27 {
  28     INT x = *(INT *)&f;
  29     INT y = *(INT *)&g;
  30
  31     if (x < 0)
  32         x = INT_MIN - x;
  33     if (y < 0)
  34         y = INT_MIN - y;
  35
  36     if (abs(x - y) > ulps)
  37         return FALSE;
  38
  39     return TRUE;
  40 }
  41
  42 static inline INT get_int(D3DXPARAMETER_TYPE type, LPCVOID data)
  43 {
  44     INT i;
  45
  46     switch (type)
  47     {
  48         case D3DXPT_FLOAT:
  49             i = *(FLOAT *)data;
  50             break;
  51
  52         case D3DXPT_INT:
  53             i = *(INT *)data;
  54             break;
  55
  56         case D3DXPT_BOOL:
  57             i = *(BOOL *)data;
  58             break;
  59
  60         default:
  61             i = 0;
  62             ok(0, "Unhandled type %x.\n", type);
  63             break;
  64     }
  65
  66     return i;
  67 }
  68
  69 static inline FLOAT get_float(D3DXPARAMETER_TYPE type, LPCVOID data)
  70 {
  71     FLOAT f;
  72
  73     switch (type)
  74     {
  75         case D3DXPT_FLOAT:
  76             f = *(FLOAT *)data;
  77             break;
  78
  79         case D3DXPT_INT:
  80             f = *(INT *)data;
  81             break;
  82
  83         case D3DXPT_BOOL:
  84             f = *(BOOL *)data;
  85             break;
  86
  87         default:
  88             f = 0.0f;
  89             ok(0, "Unhandled type %x.\n", type);
  90             break;
  91     }
  92
  93     return f;
  94 }
  95
  96 static inline BOOL get_bool(LPCVOID data)
  97 {
  98     return (*(BOOL *)data) ? TRUE : FALSE;
  99 }
 100
 101 static void set_number(LPVOID outdata, D3DXPARAMETER_TYPE outtype, LPCVOID indata, D3DXPARAMETER_TYPE intype)
 102 {
 103     switch (outtype)
 104     {
 105         case D3DXPT_FLOAT:
 106             *(FLOAT *)outdata = get_float(intype, indata);
 107             break;
 108
 109         case D3DXPT_BOOL:
 110             *(BOOL *)outdata = get_bool(indata);
 111             break;
 112
 113         case D3DXPT_INT:
 114             *(INT *)outdata = get_int(intype, indata);
 115             break;
 116
 117         case D3DXPT_PIXELSHADER:
 118         case D3DXPT_VERTEXSHADER:
 119         case D3DXPT_TEXTURE2D:
 120         case D3DXPT_STRING:
 121             *(INT *)outdata = 0x12345678;
 122             break;
 123
 124         default:
 125             ok(0, "Unhandled type %x.\n", outtype);
 126             *(INT *)outdata = 0;
 127             break;
 128     }
 129 }
 130
 131 static const char effect_desc[] =
 132 "Technique\n"
 133 "{\n"
 134 "}\n";
 135
 136 static void test_create_effect_and_pool(IDirect3DDevice9 *device)
 137 {
 138     HRESULT hr;
 139     ID3DXEffect *effect;
 140     ID3DXBaseEffect *base;
 141     ULONG count;
 142     IDirect3DDevice9 *device2;
 143     LPD3DXEFFECTSTATEMANAGER manager = (LPD3DXEFFECTSTATEMANAGER)0xdeadbeef;
 144     ID3DXEffectPool *pool = (ID3DXEffectPool *)0xdeadbeef, *pool2;
 145
 146     hr = D3DXCreateEffect(NULL, effect_desc, sizeof(effect_desc), NULL, NULL, 0, NULL, NULL, NULL);
 147     ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 148
 149     hr = D3DXCreateEffect(device, NULL, 0, NULL, NULL, 0, NULL, NULL, NULL);
 150     ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 151
 152     hr = D3DXCreateEffect(device, effect_desc, 0, NULL, NULL, 0, NULL, NULL, NULL);
 153     ok(hr == E_FAIL, "Got result %x, expected %x (D3DXERR_INVALIDDATA)\n", hr, E_FAIL);
 154
 155     hr = D3DXCreateEffect(device, effect_desc, sizeof(effect_desc), NULL, NULL, 0, NULL, NULL, NULL);
 156     ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
 157
 158     hr = D3DXCreateEffect(device, effect_desc, sizeof(effect_desc), NULL, NULL, 0, NULL, &effect, NULL);
 159     ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
 160
 161     hr = effect->lpVtbl->QueryInterface(effect, &IID_ID3DXBaseEffect, (void **)&base);
 162     ok(hr == E_NOINTERFACE, "QueryInterface failed, got %x, expected %x (E_NOINTERFACE)\n", hr, E_NOINTERFACE);
 163
 164     hr = effect->lpVtbl->GetStateManager(effect, NULL);
 165     ok(hr == D3DERR_INVALIDCALL, "GetStateManager failed, got %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 166
 167     hr = effect->lpVtbl->GetStateManager(effect, &manager);
 168     ok(hr == D3D_OK, "GetStateManager failed, got %x, expected 0 (D3D_OK)\n", hr);
 169     ok(!manager, "GetStateManager failed, got %p\n", manager);
 170
 171     /* this works, but it is not recommended! */
 172     hr = effect->lpVtbl->SetStateManager(effect, (LPD3DXEFFECTSTATEMANAGER) device);
 173     ok(hr == D3D_OK, "SetStateManager failed, got %x, expected 0 (D3D_OK)\n", hr);
 174
 175     hr = effect->lpVtbl->GetStateManager(effect, &manager);
 176     ok(hr == D3D_OK, "GetStateManager failed, got %x, expected 0 (D3D_OK)\n", hr);
 177     ok(manager != NULL, "GetStateManager failed\n");
 178
 179     IDirect3DDevice9_AddRef(device);
 180     count = IDirect3DDevice9_Release(device);
 181     ok(count == 4, "Release failed, got %u, expected 4\n", count);
 182
 183     count = IUnknown_Release(manager);
 184     ok(count == 3, "Release failed, got %u, expected 3\n", count);
 185
 186     hr = effect->lpVtbl->SetStateManager(effect, NULL);
 187     ok(hr == D3D_OK, "SetStateManager failed, got %x, expected 0 (D3D_OK)\n", hr);
 188
 189     hr = effect->lpVtbl->GetPool(effect, &pool);
 190     ok(hr == D3D_OK, "GetPool failed, got %x, expected 0 (D3D_OK)\n", hr);
 191     ok(!pool, "GetPool failed, got %p\n", pool);
 192
 193     hr = effect->lpVtbl->GetPool(effect, NULL);
 194     ok(hr == D3DERR_INVALIDCALL, "GetPool failed, got %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 195
 196     hr = effect->lpVtbl->GetDevice(effect, &device2);
 197     ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
 198
 199     hr = effect->lpVtbl->GetDevice(effect, NULL);
 200     ok(hr == D3DERR_INVALIDCALL, "GetDevice failed, got %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 201
 202     count = IDirect3DDevice9_Release(device2);
 203     ok(count == 2, "Release failed, got %u, expected 2\n", count);
 204
 205     count = effect->lpVtbl->Release(effect);
 206     ok(count == 0, "Release failed %u\n", count);
 207
 208     hr = D3DXCreateEffectPool(NULL);
 209     ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 210
 211     hr = D3DXCreateEffectPool(&pool);
 212     ok(hr == S_OK, "Got result %x, expected 0 (S_OK)\n", hr);
 213
 214     count = pool->lpVtbl->Release(pool);
 215     ok(count == 0, "Release failed %u\n", count);
 216
 217     hr = D3DXCreateEffectPool(&pool);
 218     ok(hr == S_OK, "Got result %x, expected 0 (S_OK)\n", hr);
 219
 220     hr = D3DXCreateEffect(device, effect_desc, sizeof(effect_desc), NULL, NULL, 0, pool, NULL, NULL);
 221     ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
 222
 223     hr = pool->lpVtbl->QueryInterface(pool, &IID_ID3DXEffectPool, (void **)&pool2);
 224     ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
 225     ok(pool == pool2, "Release failed, got %p, expected %p\n", pool2, pool);
 226
 227     count = pool2->lpVtbl->Release(pool2);
 228     ok(count == 1, "Release failed, got %u, expected 1\n", count);
 229
 230     hr = IDirect3DDevice9_QueryInterface(device, &IID_IDirect3DDevice9, (void **)&device2);
 231     ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
 232
 233     count = IDirect3DDevice9_Release(device2);
 234     ok(count == 1, "Release failed, got %u, expected 1\n", count);
 235
 236     hr = D3DXCreateEffect(device, effect_desc, sizeof(effect_desc), NULL, NULL, 0, pool, &effect, NULL);
 237     ok(hr == D3D_OK, "Got result %x, expected 0 (D3D_OK)\n", hr);
 238
 239     hr = effect->lpVtbl->GetPool(effect, &pool);
 240     ok(hr == D3D_OK, "GetPool failed, got %x, expected 0 (D3D_OK)\n", hr);
 241     ok(pool == pool2, "GetPool failed, got %p, expected %p\n", pool2, pool);
 242
 243     count = pool2->lpVtbl->Release(pool2);
 244     ok(count == 2, "Release failed, got %u, expected 2\n", count);
 245
 246     count = effect->lpVtbl->Release(effect);
 247     ok(count == 0, "Release failed %u\n", count);
 248
 249     count = pool->lpVtbl->Release(pool);
 250     ok(count == 0, "Release failed %u\n", count);
 251 }
 252
 253 static void test_create_effect_compiler(void)
 254 {
 255     HRESULT hr;
 256     ID3DXEffectCompiler *compiler, *compiler2;
 257     ID3DXBaseEffect *base;
 258     IUnknown *unknown;
 259     ULONG count;
 260
 261     hr = D3DXCreateEffectCompiler(NULL, 0, NULL, NULL, 0, &compiler, NULL);
 262     ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 263
 264     hr = D3DXCreateEffectCompiler(NULL, 0, NULL, NULL, 0, NULL, NULL);
 265     ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 266
 267     hr = D3DXCreateEffectCompiler(effect_desc, 0, NULL, NULL, 0, &compiler, NULL);
 268     ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);
 269
 270     count = compiler->lpVtbl->Release(compiler);
 271     ok(count == 0, "Release failed %u\n", count);
 272
 273     hr = D3DXCreateEffectCompiler(effect_desc, 0, NULL, NULL, 0, NULL, NULL);
 274     ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 275
 276     hr = D3DXCreateEffectCompiler(NULL, sizeof(effect_desc), NULL, NULL, 0, &compiler, NULL);
 277     ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 278
 279     hr = D3DXCreateEffectCompiler(NULL, sizeof(effect_desc), NULL, NULL, 0, NULL, NULL);
 280     ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3D_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 281
 282     hr = D3DXCreateEffectCompiler(effect_desc, sizeof(effect_desc), NULL, NULL, 0, NULL, NULL);
 283     ok(hr == D3DERR_INVALIDCALL, "Got result %x, expected %x (D3DERR_INVALIDCALL)\n", hr, D3DERR_INVALIDCALL);
 284
 285     hr = D3DXCreateEffectCompiler(effect_desc, sizeof(effect_desc), NULL, NULL, 0, &compiler, NULL);
 286     ok(hr == D3D_OK, "Got result %x, expected %x (D3D_OK)\n", hr, D3D_OK);
 287
 288     hr = compiler->lpVtbl->QueryInterface(compiler, &IID_ID3DXBaseEffect, (void **)&base);
 289     ok(hr == E_NOINTERFACE, "QueryInterface failed, got %x, expected %x (E_NOINTERFACE)\n", hr, E_NOINTERFACE);
 290
 291     hr = compiler->lpVtbl->QueryInterface(compiler, &IID_ID3DXEffectCompiler, (void **)&compiler2);
 292     ok(hr == D3D_OK, "QueryInterface failed, got %x, expected %x (D3D_OK)\n", hr, D3D_OK);
 293
 294     hr = compiler->lpVtbl->QueryInterface(compiler, &IID_IUnknown, (void **)&unknown);
 295     ok(hr == D3D_OK, "QueryInterface failed, got %x, expected %x (D3D_OK)\n", hr, D3D_OK);
 296
 297     count = unknown->lpVtbl->Release(unknown);
 298     ok(count == 2, "Release failed, got %u, expected %u\n", count, 2);
 299
 300     count = compiler2->lpVtbl->Release(compiler2);
 301     ok(count == 1, "Release failed, got %u, expected %u\n", count, 1);
 302
 303     count = compiler->lpVtbl->Release(compiler);
 304     ok(count == 0, "Release failed %u\n", count);
 305 }
 306
 307 /*
 308  * Parameter value test
 309  */
 310 struct test_effect_parameter_value_result
 311 {
 312     LPCSTR full_name;
 313     D3DXPARAMETER_DESC desc;
 314     UINT value_offset; /* start position for the value in the blob */
 315 };
 316
 317 /*
 318  * fxc.exe /Tfx_2_0
 319  */
 320 #if 0
 321 float f = 0.1;
 322 float1 f1 = {1.1};
 323 float2 f2 = {2.1, 2.2};
 324 float3 f3 = {3.1, 3.2, 3.3};
 325 float4 f4 = {4.1, 4.2, 4.3, 4.4};
 326 float1x1 f11 = {11.1};
 327 float1x2 f12 = {12.1, 12.2};
 328 float1x3 f13 = {13.1, 13.2, 13.3};
 329 float1x4 f14 = {14.1, 14.2, 14.3, 14.4};
 330 float2x1 f21 = {{21.11, 21.21}};
 331 float2x2 f22 = {{22.11, 22.21}, {22.12, 22.22}};
 332 float2x3 f23 = {{23.11, 23.21}, {23.12, 23.22}, {23.13, 23.23}};
 333 float2x4 f24 = {{24.11, 24.21}, {24.12, 24.22}, {24.13, 24.23}, {24.14, 24.24}};
 334 float3x1 f31 = {{31.11, 31.21, 31.31}};
 335 float3x2 f32 = {{32.11, 32.21, 32.31}, {32.12, 32.22, 32.32}};
 336 float3x3 f33 = {{33.11, 33.21, 33.31}, {33.12, 33.22, 33.32},
 337         {33.13, 33.23, 33.33}};
 338 float3x4 f34 = {{34.11, 34.21, 34.31}, {34.12, 34.22, 34.32},
 339         {34.13, 34.23, 34.33}, {34.14, 34.24, 34.34}};
 340 float4x1 f41 = {{41.11, 41.21, 41.31, 41.41}};
 341 float4x2 f42 = {{42.11, 42.21, 42.31, 42.41}, {42.12, 42.22, 42.32, 42.42}};
 342 float4x3 f43 = {{43.11, 43.21, 43.31, 43.41}, {43.12, 43.22, 43.32, 43.42},
 343         {43.13, 43.23, 43.33, 43.43}};
 344 float4x4 f44 = {{44.11, 44.21, 44.31, 44.41}, {44.12, 44.22, 44.32, 44.42},
 345         {44.13, 44.23, 44.33, 44.43}, {44.14, 44.24, 44.34, 44.44}};
 346 float f_2[2] = {0.101, 0.102};
 347 float1 f1_2[2] = {{1.101}, {1.102}};
 348 float2 f2_2[2] = {{2.101, 2.201}, {2.102, 2.202}};
 349 float3 f3_2[2] = {{3.101, 3.201, 3.301}, {3.102, 3.202, 3.302}};
 350 float4 f4_2[2] = {{4.101, 4.201, 4.301, 4.401}, {4.102, 4.202, 4.302, 4.402}};
 351 float1x1 f11_2[2] = {{11.101}, {11.102}};
 352 float1x2 f12_2[2] = {{12.101, 12.201}, {12.102, 12.202}};
 353 float1x3 f13_2[2] = {{13.101, 13.201, 13.301}, {13.102, 13.202, 13.302}};
 354 float1x4 f14_2[2] = {{14.101, 14.201, 14.301, 14.401}, {14.102, 14.202, 14.302, 14.402}};
 355 float2x1 f21_2[2] = {{{21.1101, 21.2101}}, {{21.1102, 21.2102}}};
 356 float2x2 f22_2[2] = {{{22.1101, 22.2101}, {22.1201, 22.2201}}, {{22.1102, 22.2102}, {22.1202, 22.2202}}};
 357 float2x3 f23_2[2] = {{{23.1101, 23.2101}, {23.1201, 23.2201}, {23.1301, 23.2301}}, {{23.1102, 23.2102},
 358         {23.1202, 23.2202}, {23.1302, 23.2302}}};
 359 float2x4 f24_2[2] = {{{24.1101, 24.2101}, {24.1201, 24.2201}, {24.1301, 24.2301}, {24.1401, 24.2401}},
 360         {{24.1102, 24.2102}, {24.1202, 24.2202}, {24.1302, 24.2302}, {24.1402, 24.2402}}};
 361 float3x1 f31_2[2] = {{{31.1101, 31.2101, 31.3101}}, {{31.1102, 31.2102, 31.3102}}};
 362 float3x2 f32_2[2] = {{{32.1101, 32.2101, 32.3101}, {32.1201, 32.2201, 32.3201}},
 363         {{32.1102, 32.2102, 32.3102}, {32.1202, 32.2202, 32.3202}}};
 364 float3x3 f33_2[2] = {{{33.1101, 33.2101, 33.3101}, {33.1201, 33.2201, 33.3201},
 365         {33.1301, 33.2301, 33.3301}}, {{33.1102, 33.2102, 33.3102}, {33.1202, 33.2202, 33.3202},
 366         {33.1302, 33.2302, 33.3302}}};
 367 float3x4 f34_2[2] = {{{34.1101, 34.2101, 34.3101}, {34.1201, 34.2201, 34.3201},
 368         {34.1301, 34.2301, 34.3301}, {34.1401, 34.2401, 34.3401}}, {{34.1102, 34.2102, 34.3102},
 369         {34.1202, 34.2202, 34.3202}, {34.1302, 34.2302, 34.3302}, {34.1402, 34.2402, 34.3402}}};
 370 float4x1 f41_2[2] = {{{41.1101, 41.2101, 41.3101, 41.4101}}, {{41.1102, 41.2102, 41.3102, 41.4102}}};
 371 float4x2 f42_2[2] = {{{42.1101, 42.2101, 42.3101, 42.4101}, {42.1201, 42.2201, 42.3201, 42.4201}},
 372         {{42.1102, 42.2102, 42.3102, 42.4102}, {42.1202, 42.2202, 42.3202, 42.4202}}};
 373 float4x3 f43_2[2] = {{{43.1101, 43.2101, 43.3101, 43.4101}, {43.1201, 43.2201, 43.3201, 43.4201},
 374         {43.1301, 43.2301, 43.3301, 43.4301}}, {{43.1102, 43.2102, 43.3102, 43.4102},
 375         {43.1202, 43.2202, 43.3202, 43.4202}, {43.1302, 43.2302, 43.3302, 43.4302}}};
 376 float4x4 f44_2[2] = {{{44.1101, 44.2101, 44.3101, 44.4101}, {44.1201, 44.2201, 44.3201, 44.4201},
 377         {44.1301, 44.2301, 44.3301, 44.4301}, {44.1401, 44.2401, 44.3401, 44.4401}},
 378         {{44.1102, 44.2102, 44.3102, 44.4102}, {44.1202, 44.2202, 44.3202, 44.4202},
 379         {44.1302, 44.2302, 44.3302, 44.4302}, {44.1402, 44.2402, 44.3402, 44.4402}}};
 380 technique t { pass p { } }
 381 #endif
 382 static const DWORD test_effect_parameter_value_blob_float[] =
 383 {
 384 0xfeff0901, 0x00000b80, 0x00000000, 0x00000003, 0x00000000, 0x00000024, 0x00000000, 0x00000000,
 385 0x00000001, 0x00000001, 0x3dcccccd, 0x00000002, 0x00000066, 0x00000003, 0x00000001, 0x0000004c,
 386 0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x3f8ccccd, 0x00000003, 0x00003166, 0x00000003,
 387 0x00000001, 0x00000078, 0x00000000, 0x00000000, 0x00000002, 0x00000001, 0x40066666, 0x400ccccd,
 388 0x00000003, 0x00003266, 0x00000003, 0x00000001, 0x000000a8, 0x00000000, 0x00000000, 0x00000003,
 389 0x00000001, 0x40466666, 0x404ccccd, 0x40533333, 0x00000003, 0x00003366, 0x00000003, 0x00000001,
 390 0x000000dc, 0x00000000, 0x00000000, 0x00000004, 0x00000001, 0x40833333, 0x40866666, 0x4089999a,
 391 0x408ccccd, 0x00000003, 0x00003466, 0x00000003, 0x00000002, 0x00000104, 0x00000000, 0x00000000,
 392 0x00000001, 0x00000001, 0x4131999a, 0x00000004, 0x00313166, 0x00000003, 0x00000002, 0x00000130,
 393 0x00000000, 0x00000000, 0x00000001, 0x00000002, 0x4141999a, 0x41433333, 0x00000004, 0x00323166,
 394 0x00000003, 0x00000002, 0x00000160, 0x00000000, 0x00000000, 0x00000001, 0x00000003, 0x4151999a,
 395 0x41533333, 0x4154cccd, 0x00000004, 0x00333166, 0x00000003, 0x00000002, 0x00000194, 0x00000000,
 396 0x00000000, 0x00000001, 0x00000004, 0x4161999a, 0x41633333, 0x4164cccd, 0x41666666, 0x00000004,
 397 0x00343166, 0x00000003, 0x00000002, 0x000001c0, 0x00000000, 0x00000000, 0x00000002, 0x00000001,
 398 0x41a8e148, 0x41a9ae14, 0x00000004, 0x00313266, 0x00000003, 0x00000002, 0x000001f4, 0x00000000,
 399 0x00000000, 0x00000002, 0x00000002, 0x41b0e148, 0x41b1ae14, 0x41b0f5c3, 0x41b1c28f, 0x00000004,
 400 0x00323266, 0x00000003, 0x00000002, 0x00000230, 0x00000000, 0x00000000, 0x00000002, 0x00000003,
 401 0x41b8e148, 0x41b9ae14, 0x41b8f5c3, 0x41b9c28f, 0x41b90a3d, 0x41b9d70a, 0x00000004, 0x00333266,
 402 0x00000003, 0x00000002, 0x00000274, 0x00000000, 0x00000000, 0x00000002, 0x00000004, 0x41c0e148,
 403 0x41c1ae14, 0x41c0f5c3, 0x41c1c28f, 0x41c10a3d, 0x41c1d70a, 0x41c11eb8, 0x41c1eb85, 0x00000004,
 404 0x00343266, 0x00000003, 0x00000002, 0x000002a4, 0x00000000, 0x00000000, 0x00000003, 0x00000001,
 405 0x41f8e148, 0x41f9ae14, 0x41fa7ae1, 0x00000004, 0x00313366, 0x00000003, 0x00000002, 0x000002e0,
 406 0x00000000, 0x00000000, 0x00000003, 0x00000002, 0x420070a4, 0x4200d70a, 0x42013d71, 0x42007ae1,
 407 0x4200e148, 0x420147ae, 0x00000004, 0x00323366, 0x00000003, 0x00000002, 0x00000328, 0x00000000,
 408 0x00000000, 0x00000003, 0x00000003, 0x420470a4, 0x4204d70a, 0x42053d71, 0x42047ae1, 0x4204e148,
 409 0x420547ae, 0x4204851f, 0x4204eb85, 0x420551ec, 0x00000004, 0x00333366, 0x00000003, 0x00000002,
 410 0x0000037c, 0x00000000, 0x00000000, 0x00000003, 0x00000004, 0x420870a4, 0x4208d70a, 0x42093d71,
 411 0x42087ae1, 0x4208e148, 0x420947ae, 0x4208851f, 0x4208eb85, 0x420951ec, 0x42088f5c, 0x4208f5c3,
 412 0x42095c29, 0x00000004, 0x00343366, 0x00000003, 0x00000002, 0x000003b0, 0x00000000, 0x00000000,
 413 0x00000004, 0x00000001, 0x422470a4, 0x4224d70a, 0x42253d71, 0x4225a3d7, 0x00000004, 0x00313466,
 414 0x00000003, 0x00000002, 0x000003f4, 0x00000000, 0x00000000, 0x00000004, 0x00000002, 0x422870a4,
 415 0x4228d70a, 0x42293d71, 0x4229a3d7, 0x42287ae1, 0x4228e148, 0x422947ae, 0x4229ae14, 0x00000004,
 416 0x00323466, 0x00000003, 0x00000002, 0x00000448, 0x00000000, 0x00000000, 0x00000004, 0x00000003,
 417 0x422c70a4, 0x422cd70a, 0x422d3d71, 0x422da3d7, 0x422c7ae1, 0x422ce148, 0x422d47ae, 0x422dae14,
 418 0x422c851f, 0x422ceb85, 0x422d51ec, 0x422db852, 0x00000004, 0x00333466, 0x00000003, 0x00000002,
 419 0x000004ac, 0x00000000, 0x00000000, 0x00000004, 0x00000004, 0x423070a4, 0x4230d70a, 0x42313d71,
 420 0x4231a3d7, 0x42307ae1, 0x4230e148, 0x423147ae, 0x4231ae14, 0x4230851f, 0x4230eb85, 0x423151ec,
 421 0x4231b852, 0x42308f5c, 0x4230f5c3, 0x42315c29, 0x4231c28f, 0x00000004, 0x00343466, 0x00000003,
 422 0x00000000, 0x000004d8, 0x00000000, 0x00000002, 0x00000001, 0x00000001, 0x3dced917, 0x3dd0e560,
 423 0x00000004, 0x00325f66, 0x00000003, 0x00000001, 0x00000504, 0x00000000, 0x00000002, 0x00000001,
 424 0x00000001, 0x3f8ced91, 0x3f8d0e56, 0x00000005, 0x325f3166, 0x00000000, 0x00000003, 0x00000001,
 425 0x0000053c, 0x00000000, 0x00000002, 0x00000002, 0x00000001, 0x400676c9, 0x400cdd2f, 0x4006872b,
 426 0x400ced91, 0x00000005, 0x325f3266, 0x00000000, 0x00000003, 0x00000001, 0x0000057c, 0x00000000,
 427 0x00000002, 0x00000003, 0x00000001, 0x404676c9, 0x404cdd2f, 0x40534396, 0x4046872b, 0x404ced91,
 428 0x405353f8, 0x00000005, 0x325f3366, 0x00000000, 0x00000003, 0x00000001, 0x000005c4, 0x00000000,
 429 0x00000002, 0x00000004, 0x00000001, 0x40833b64, 0x40866e98, 0x4089a1cb, 0x408cd4fe, 0x40834396,
 430 0x408676c9, 0x4089a9fc, 0x408cdd2f, 0x00000005, 0x325f3466, 0x00000000, 0x00000003, 0x00000002,
 431 0x000005f4, 0x00000000, 0x00000002, 0x00000001, 0x00000001, 0x41319db2, 0x4131a1cb, 0x00000006,
 432 0x5f313166, 0x00000032, 0x00000003, 0x00000002, 0x0000062c, 0x00000000, 0x00000002, 0x00000001,
 433 0x00000002, 0x41419db2, 0x4143374c, 0x4141a1cb, 0x41433b64, 0x00000006, 0x5f323166, 0x00000032,
 434 0x00000003, 0x00000002, 0x0000066c, 0x00000000, 0x00000002, 0x00000001, 0x00000003, 0x41519db2,
 435 0x4153374c, 0x4154d0e5, 0x4151a1cb, 0x41533b64, 0x4154d4fe, 0x00000006, 0x5f333166, 0x00000032,
 436 0x00000003, 0x00000002, 0x000006b4, 0x00000000, 0x00000002, 0x00000001, 0x00000004, 0x41619db2,
 437 0x4163374c, 0x4164d0e5, 0x41666a7f, 0x4161a1cb, 0x41633b64, 0x4164d4fe, 0x41666e98, 0x00000006,
 438 0x5f343166, 0x00000032, 0x00000003, 0x00000002, 0x000006ec, 0x00000000, 0x00000002, 0x00000002,
 439 0x00000001, 0x41a8e17c, 0x41a9ae49, 0x41a8e1b1, 0x41a9ae7d, 0x00000006, 0x5f313266, 0x00000032,
 440 0x00000003, 0x00000002, 0x00000734, 0x00000000, 0x00000002, 0x00000002, 0x00000002, 0x41b0e17c,
 441 0x41b1ae49, 0x41b0f5f7, 0x41b1c2c4, 0x41b0e1b1, 0x41b1ae7d, 0x41b0f62b, 0x41b1c2f8, 0x00000006,
 442 0x5f323266, 0x00000032, 0x00000003, 0x00000002, 0x0000078c, 0x00000000, 0x00000002, 0x00000002,
 443 0x00000003, 0x41b8e17c, 0x41b9ae49, 0x41b8f5f7, 0x41b9c2c4, 0x41b90a72, 0x41b9d73f, 0x41b8e1b1,
 444 0x41b9ae7d, 0x41b8f62b, 0x41b9c2f8, 0x41b90aa6, 0x41b9d773, 0x00000006, 0x5f333266, 0x00000032,
 445 0x00000003, 0x00000002, 0x000007f4, 0x00000000, 0x00000002, 0x00000002, 0x00000004, 0x41c0e17c,
 446 0x41c1ae49, 0x41c0f5f7, 0x41c1c2c4, 0x41c10a72, 0x41c1d73f, 0x41c11eed, 0x41c1ebba, 0x41c0e1b1,
 447 0x41c1ae7d, 0x41c0f62b, 0x41c1c2f8, 0x41c10aa6, 0x41c1d773, 0x41c11f21, 0x41c1ebee, 0x00000006,
 448 0x5f343266, 0x00000032, 0x00000003, 0x00000002, 0x00000834, 0x00000000, 0x00000002, 0x00000003,
 449 0x00000001, 0x41f8e17c, 0x41f9ae49, 0x41fa7b16, 0x41f8e1b1, 0x41f9ae7d, 0x41fa7b4a, 0x00000006,
 450 0x5f313366, 0x00000032, 0x00000003, 0x00000002, 0x0000088c, 0x00000000, 0x00000002, 0x00000003,
 451 0x00000002, 0x420070be, 0x4200d724, 0x42013d8b, 0x42007afb, 0x4200e162, 0x420147c8, 0x420070d8,
 452 0x4200d73f, 0x42013da5, 0x42007b16, 0x4200e17c, 0x420147e3, 0x00000006, 0x5f323366, 0x00000032,
 453 0x00000003, 0x00000002, 0x000008fc, 0x00000000, 0x00000002, 0x00000003, 0x00000003, 0x420470be,
 454 0x4204d724, 0x42053d8b, 0x42047afb, 0x4204e162, 0x420547c8, 0x42048539, 0x4204eb9f, 0x42055206,
 455 0x420470d8, 0x4204d73f, 0x42053da5, 0x42047b16, 0x4204e17c, 0x420547e3, 0x42048553, 0x4204ebba,
 456 0x42055220, 0x00000006, 0x5f333366, 0x00000032, 0x00000003, 0x00000002, 0x00000984, 0x00000000,
 457 0x00000002, 0x00000003, 0x00000004, 0x420870be, 0x4208d724, 0x42093d8b, 0x42087afb, 0x4208e162,
 458 0x420947c8, 0x42088539, 0x4208eb9f, 0x42095206, 0x42088f76, 0x4208f5dd, 0x42095c43, 0x420870d8,
 459 0x4208d73f, 0x42093da5, 0x42087b16, 0x4208e17c, 0x420947e3, 0x42088553, 0x4208ebba, 0x42095220,
 460 0x42088f91, 0x4208f5f7, 0x42095c5d, 0x00000006, 0x5f343366, 0x00000032, 0x00000003, 0x00000002,
 461 0x000009cc, 0x00000000, 0x00000002, 0x00000004, 0x00000001, 0x422470be, 0x4224d724, 0x42253d8b,
 462 0x4225a3f1, 0x422470d8, 0x4224d73f, 0x42253da5, 0x4225a40b, 0x00000006, 0x5f313466, 0x00000032,
 463 0x00000003, 0x00000002, 0x00000a34, 0x00000000, 0x00000002, 0x00000004, 0x00000002, 0x422870be,
 464 0x4228d724, 0x42293d8b, 0x4229a3f1, 0x42287afb, 0x4228e162, 0x422947c8, 0x4229ae2f, 0x422870d8,
 465 0x4228d73f, 0x42293da5, 0x4229a40b, 0x42287b16, 0x4228e17c, 0x422947e3, 0x4229ae49, 0x00000006,
 466 0x5f323466, 0x00000032, 0x00000003, 0x00000002, 0x00000abc, 0x00000000, 0x00000002, 0x00000004,
 467 0x00000003, 0x422c70be, 0x422cd724, 0x422d3d8b, 0x422da3f1, 0x422c7afb, 0x422ce162, 0x422d47c8,
 468 0x422dae2f, 0x422c8539, 0x422ceb9f, 0x422d5206, 0x422db86c, 0x422c70d8, 0x422cd73f, 0x422d3da5,
 469 0x422da40b, 0x422c7b16, 0x422ce17c, 0x422d47e3, 0x422dae49, 0x422c8553, 0x422cebba, 0x422d5220,
 470 0x422db886, 0x00000006, 0x5f333466, 0x00000032, 0x00000003, 0x00000002, 0x00000b64, 0x00000000,
 471 0x00000002, 0x00000004, 0x00000004, 0x423070be, 0x4230d724, 0x42313d8b, 0x4231a3f1, 0x42307afb,
 472 0x4230e162, 0x423147c8, 0x4231ae2f, 0x42308539, 0x4230eb9f, 0x42315206, 0x4231b86c, 0x42308f76,
 473 0x4230f5dd, 0x42315c43, 0x4231c2aa, 0x423070d8, 0x4230d73f, 0x42313da5, 0x4231a40b, 0x42307b16,
 474 0x4230e17c, 0x423147e3, 0x4231ae49, 0x42308553, 0x4230ebba, 0x42315220, 0x4231b886, 0x42308f91,
 475 0x4230f5f7, 0x42315c5d, 0x4231c2c4, 0x00000006, 0x5f343466, 0x00000032, 0x00000002, 0x00000070,
 476 0x00000002, 0x00000074, 0x0000002a, 0x00000001, 0x00000001, 0x00000001, 0x00000004, 0x00000020,
 477 0x00000000, 0x00000000, 0x0000002c, 0x00000048, 0x00000000, 0x00000000, 0x00000054, 0x00000070,
 478 0x00000000, 0x00000000, 0x00000080, 0x0000009c, 0x00000000, 0x00000000, 0x000000b0, 0x000000cc,
 479 0x00000000, 0x00000000, 0x000000e4, 0x00000100, 0x00000000, 0x00000000, 0x0000010c, 0x00000128,
 480 0x00000000, 0x00000000, 0x00000138, 0x00000154, 0x00000000, 0x00000000, 0x00000168, 0x00000184,
 481 0x00000000, 0x00000000, 0x0000019c, 0x000001b8, 0x00000000, 0x00000000, 0x000001c8, 0x000001e4,
 482 0x00000000, 0x00000000, 0x000001fc, 0x00000218, 0x00000000, 0x00000000, 0x00000238, 0x00000254,
 483 0x00000000, 0x00000000, 0x0000027c, 0x00000298, 0x00000000, 0x00000000, 0x000002ac, 0x000002c8,
 484 0x00000000, 0x00000000, 0x000002e8, 0x00000304, 0x00000000, 0x00000000, 0x00000330, 0x0000034c,
 485 0x00000000, 0x00000000, 0x00000384, 0x000003a0, 0x00000000, 0x00000000, 0x000003b8, 0x000003d4,
 486 0x00000000, 0x00000000, 0x000003fc, 0x00000418, 0x00000000, 0x00000000, 0x00000450, 0x0000046c,
 487 0x00000000, 0x00000000, 0x000004b4, 0x000004d0, 0x00000000, 0x00000000, 0x000004e0, 0x000004fc,
 488 0x00000000, 0x00000000, 0x00000510, 0x0000052c, 0x00000000, 0x00000000, 0x00000548, 0x00000564,
 489 0x00000000, 0x00000000, 0x00000588, 0x000005a4, 0x00000000, 0x00000000, 0x000005d0, 0x000005ec,
 490 0x00000000, 0x00000000, 0x00000600, 0x0000061c, 0x00000000, 0x00000000, 0x00000638, 0x00000654,
 491 0x00000000, 0x00000000, 0x00000678, 0x00000694, 0x00000000, 0x00000000, 0x000006c0, 0x000006dc,
 492 0x00000000, 0x00000000, 0x000006f8, 0x00000714, 0x00000000, 0x00000000, 0x00000740, 0x0000075c,
 493 0x00000000, 0x00000000, 0x00000798, 0x000007b4, 0x00000000, 0x00000000, 0x00000800, 0x0000081c,
 494 0x00000000, 0x00000000, 0x00000840, 0x0000085c, 0x00000000, 0x00000000, 0x00000898, 0x000008b4,
 495 0x00000000, 0x00000000, 0x00000908, 0x00000924, 0x00000000, 0x00000000, 0x00000990, 0x000009ac,
 496 0x00000000, 0x00000000, 0x000009d8, 0x000009f4, 0x00000000, 0x00000000, 0x00000a40, 0x00000a5c,
 497 0x00000000, 0x00000000, 0x00000ac8, 0x00000ae4, 0x00000000, 0x00000000, 0x00000b78, 0x00000000,
 498 0x00000001, 0x00000b70, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
 499 };
 500
 501 struct test_effect_parameter_value_result test_effect_parameter_value_result_float[] =
 502 {
 503     {"f",     {"f",     NULL, D3DXPC_SCALAR,      D3DXPT_FLOAT, 1, 1, 0, 0, 0, 0,   4},  10},
 504     {"f1",    {"f1",    NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 1, 0, 0, 0, 0,   4},  20},
 505     {"f2",    {"f2",    NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 2, 0, 0, 0, 0,   8},  30},
 506     {"f3",    {"f3",    NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 3, 0, 0, 0, 0,  12},  41},
 507     {"f4",    {"f4",    NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 4, 0, 0, 0, 0,  16},  53},
 508     {"f11",   {"f11",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 1, 1, 0, 0, 0, 0,   4},  66},
 509     {"f12",   {"f12",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 1, 2, 0, 0, 0, 0,   8},  76},
 510     {"f13",   {"f13",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 1, 3, 0, 0, 0, 0,  12},  87},
 511     {"f14",   {"f14",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 1, 4, 0, 0, 0, 0,  16},  99},
 512     {"f21",   {"f21",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 2, 1, 0, 0, 0, 0,   8}, 112},
 513     {"f22",   {"f22",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 2, 2, 0, 0, 0, 0,  16}, 123},
 514     {"f23",   {"f23",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 2, 3, 0, 0, 0, 0,  24}, 136},
 515     {"f24",   {"f24",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 2, 4, 0, 0, 0, 0,  32}, 151},
 516     {"f31",   {"f31",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 3, 1, 0, 0, 0, 0,  12}, 168},
 517     {"f32",   {"f32",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 3, 2, 0, 0, 0, 0,  24}, 180},
 518     {"f33",   {"f33",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 3, 3, 0, 0, 0, 0,  36}, 195},
 519     {"f34",   {"f34",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 3, 4, 0, 0, 0, 0,  48}, 213},
 520     {"f41",   {"f41",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 4, 1, 0, 0, 0, 0,  16}, 234},
 521     {"f42",   {"f42",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 4, 2, 0, 0, 0, 0,  32}, 247},
 522     {"f43",   {"f43",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 4, 3, 0, 0, 0, 0,  48}, 264},
 523     {"f44",   {"f44",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 4, 4, 0, 0, 0, 0,  64}, 285},
 524     {"f_2",   {"f_2",   NULL, D3DXPC_SCALAR,      D3DXPT_FLOAT, 1, 1, 2, 0, 0, 0,   8}, 310},
 525     {"f1_2",  {"f1_2",  NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 1, 2, 0, 0, 0,   8}, 321},
 526     {"f2_2",  {"f2_2",  NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 2, 2, 0, 0, 0,  16}, 333},
 527     {"f3_2",  {"f3_2",  NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 3, 2, 0, 0, 0,  24}, 347},
 528     {"f4_2",  {"f4_2",  NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 4, 2, 0, 0, 0,  32}, 363},
 529     {"f11_2", {"f11_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 1, 1, 2, 0, 0, 0,   8}, 381},
 530     {"f12_2", {"f12_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 1, 2, 2, 0, 0, 0,  16}, 393},
 531     {"f13_2", {"f13_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 1, 3, 2, 0, 0, 0,  24}, 407},
 532     {"f14_2", {"f14_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 1, 4, 2, 0, 0, 0,  32}, 423},
 533     {"f21_2", {"f21_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 2, 1, 2, 0, 0, 0,  16}, 441},
 534     {"f22_2", {"f22_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 2, 2, 2, 0, 0, 0,  32}, 455},
 535     {"f23_2", {"f23_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 2, 3, 2, 0, 0, 0,  48}, 473},
 536     {"f24_2", {"f24_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 2, 4, 2, 0, 0, 0,  64}, 495},
 537     {"f31_2", {"f31_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 3, 1, 2, 0, 0, 0,  24}, 521},
 538     {"f32_2", {"f32_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 3, 2, 2, 0, 0, 0,  48}, 537},
 539     {"f33_2", {"f33_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 3, 3, 2, 0, 0, 0,  72}, 559},
 540     {"f34_2", {"f34_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 3, 4, 2, 0, 0, 0,  96}, 587},
 541     {"f41_2", {"f41_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 4, 1, 2, 0, 0, 0,  32}, 621},
 542     {"f42_2", {"f42_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 4, 2, 2, 0, 0, 0,  64}, 639},
 543     {"f43_2", {"f43_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 4, 3, 2, 0, 0, 0,  96}, 665},
 544     {"f44_2", {"f44_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_FLOAT, 4, 4, 2, 0, 0, 0, 128}, 699},
 545 };
 546
 547 /*
 548  * fxc.exe /Tfx_2_0
 549  */
 550 #if 0
 551 int i = 1;
 552 int1 i1 = {11};
 553 int2 i2 = {21, 22};
 554 int3 i3 = {31, 32, 33};
 555 int4 i4 = {41, 42, 43, 44};
 556 int1x1 i11 = {111};
 557 int1x2 i12 = {121, 122};
 558 int1x3 i13 = {131, 132, 133};
 559 int1x4 i14 = {141, 142, 143, 144};
 560 int2x1 i21 = {{2111, 2121}};
 561 int2x2 i22 = {{2211, 2221}, {2212, 2222}};
 562 int2x3 i23 = {{2311, 2321}, {2312, 2322}, {2313, 2323}};
 563 int2x4 i24 = {{2411, 2421}, {2412, 2422}, {2413, 2423}, {2414, 2424}};
 564 int3x1 i31 = {{3111, 3121, 3131}};
 565 int3x2 i32 = {{3211, 3221, 3231}, {3212, 3222, 3232}};
 566 int3x3 i33 = {{3311, 3321, 3331}, {3312, 3322, 3332},
 567         {3313, 3323, 3333}};
 568 int3x4 i34 = {{3411, 3421, 3431}, {3412, 3422, 3432},
 569         {3413, 3423, 3433}, {3414, 3424, 3434}};
 570 int4x1 i41 = {{4111, 4121, 4131, 4141}};
 571 int4x2 i42 = {{4211, 4221, 4231, 4241}, {4212, 4222, 4232, 4242}};
 572 int4x3 i43 = {{4311, 4321, 4331, 4341}, {4312, 4322, 4332, 4342},
 573         {4313, 4323, 4333, 4343}};
 574 int4x4 i44 = {{4411, 4421, 4431, 4441}, {4412, 4422, 4432, 4442},
 575         {4413, 4423, 4433, 4443}, {4414, 4424, 4434, 4444}};
 576 int i_2[2] = {0101, 0102};
 577 int1 i1_2[2] = {{1101}, {1102}};
 578 int2 i2_2[2] = {{2101, 2201}, {2102, 2202}};
 579 int3 i3_2[2] = {{3101, 3201, 3301}, {3102, 3202, 3302}};
 580 int4 i4_2[2] = {{4101, 4201, 4301, 4401}, {4102, 4202, 4302, 4402}};
 581 int1x1 i11_2[2] = {{11101}, {11102}};
 582 int1x2 i12_2[2] = {{12101, 12201}, {12102, 12202}};
 583 int1x3 i13_2[2] = {{13101, 13201, 13301}, {13102, 13202, 13302}};
 584 int1x4 i14_2[2] = {{14101, 14201, 14301, 14401}, {14102, 14202, 14302, 14402}};
 585 int2x1 i21_2[2] = {{{211101, 212101}}, {{211102, 212102}}};
 586 int2x2 i22_2[2] = {{{221101, 222101}, {221201, 222201}}, {{221102, 222102}, {221202, 222202}}};
 587 int2x3 i23_2[2] = {{{231101, 232101}, {231201, 232201}, {231301, 232301}}, {{231102, 232102},
 588         {231202, 232202}, {231302, 232302}}};
 589 int2x4 i24_2[2] = {{{241101, 242101}, {241201, 242201}, {241301, 242301}, {241401, 242401}},
 590         {{241102, 242102}, {241202, 242202}, {241302, 242302}, {241402, 242402}}};
 591 int3x1 i31_2[2] = {{{311101, 312101, 313101}}, {{311102, 312102, 313102}}};
 592 int3x2 i32_2[2] = {{{321101, 322101, 323101}, {321201, 322201, 323201}},
 593         {{321102, 322102, 323102}, {321202, 322202, 323202}}};
 594 int3x3 i33_2[2] = {{{331101, 332101, 333101}, {331201, 332201, 333201},
 595         {331301, 332301, 333301}}, {{331102, 332102, 333102}, {331202, 332202, 333202},
 596         {331302, 332302, 333302}}};
 597 int3x4 i34_2[2] = {{{341101, 342101, 343101}, {341201, 342201, 343201},
 598         {341301, 342301, 343301}, {341401, 342401, 343401}}, {{341102, 342102, 343102},
 599         {341202, 342202, 343202}, {341302, 342302, 343302}, {341402, 342402, 343402}}};
 600 int4x1 i41_2[2] = {{{411101, 412101, 413101, 414101}}, {{411102, 412102, 413102, 414102}}};
 601 int4x2 i42_2[2] = {{{421101, 422101, 423101, 424101}, {421201, 422201, 423201, 424201}},
 602         {{421102, 422102, 423102, 424102}, {421202, 422202, 423202, 424202}}};
 603 int4x3 i43_2[2] = {{{431101, 432101, 433101, 434101}, {431201, 432201, 433201, 434201},
 604         {431301, 432301, 433301, 434301}}, {{431102, 432102, 433102, 434102},
 605         {431202, 432202, 433202, 434202}, {431302, 432302, 433302, 434302}}};
 606 int4x4 i44_2[2] = {{{441101, 442101, 443101, 444101}, {441201, 442201, 443201, 444201},
 607         {441301, 442301, 443301, 444301}, {441401, 442401, 443401, 444401}},
 608         {{441102, 442102, 443102, 444102}, {441202, 442202, 443202, 444202},
 609         {441302, 442302, 443302, 444302}, {441402, 442402, 443402, 444402}}};
 610 technique t { pass p { } }
 611 #endif
 612 static const DWORD test_effect_parameter_value_blob_int[] =
 613 {
 614 0xfeff0901, 0x00000b80, 0x00000000, 0x00000002, 0x00000000, 0x00000024, 0x00000000, 0x00000000,
 615 0x00000001, 0x00000001, 0x00000001, 0x00000002, 0x00000069, 0x00000002, 0x00000001, 0x0000004c,
 616 0x00000000, 0x00000000, 0x00000001, 0x00000001, 0x0000000b, 0x00000003, 0x00003169, 0x00000002,
 617 0x00000001, 0x00000078, 0x00000000, 0x00000000, 0x00000002, 0x00000001, 0x00000015, 0x00000016,
 618 0x00000003, 0x00003269, 0x00000002, 0x00000001, 0x000000a8, 0x00000000, 0x00000000, 0x00000003,
 619 0x00000001, 0x0000001f, 0x00000020, 0x00000021, 0x00000003, 0x00003369, 0x00000002, 0x00000001,
 620 0x000000dc, 0x00000000, 0x00000000, 0x00000004, 0x00000001, 0x00000029, 0x0000002a, 0x0000002b,
 621 0x0000002c, 0x00000003, 0x00003469, 0x00000002, 0x00000002, 0x00000104, 0x00000000, 0x00000000,
 622 0x00000001, 0x00000001, 0x0000006f, 0x00000004, 0x00313169, 0x00000002, 0x00000002, 0x00000130,
 623 0x00000000, 0x00000000, 0x00000001, 0x00000002, 0x00000079, 0x0000007a, 0x00000004, 0x00323169,
 624 0x00000002, 0x00000002, 0x00000160, 0x00000000, 0x00000000, 0x00000001, 0x00000003, 0x00000083,
 625 0x00000084, 0x00000085, 0x00000004, 0x00333169, 0x00000002, 0x00000002, 0x00000194, 0x00000000,
 626 0x00000000, 0x00000001, 0x00000004, 0x0000008d, 0x0000008e, 0x0000008f, 0x00000090, 0x00000004,
 627 0x00343169, 0x00000002, 0x00000002, 0x000001c0, 0x00000000, 0x00000000, 0x00000002, 0x00000001,
 628 0x0000083f, 0x00000849, 0x00000004, 0x00313269, 0x00000002, 0x00000002, 0x000001f4, 0x00000000,
 629 0x00000000, 0x00000002, 0x00000002, 0x000008a3, 0x000008ad, 0x000008a4, 0x000008ae, 0x00000004,
 630 0x00323269, 0x00000002, 0x00000002, 0x00000230, 0x00000000, 0x00000000, 0x00000002, 0x00000003,
 631 0x00000907, 0x00000911, 0x00000908, 0x00000912, 0x00000909, 0x00000913, 0x00000004, 0x00333269,
 632 0x00000002, 0x00000002, 0x00000274, 0x00000000, 0x00000000, 0x00000002, 0x00000004, 0x0000096b,
 633 0x00000975, 0x0000096c, 0x00000976, 0x0000096d, 0x00000977, 0x0000096e, 0x00000978, 0x00000004,
 634 0x00343269, 0x00000002, 0x00000002, 0x000002a4, 0x00000000, 0x00000000, 0x00000003, 0x00000001,
 635 0x00000c27, 0x00000c31, 0x00000c3b, 0x00000004, 0x00313369, 0x00000002, 0x00000002, 0x000002e0,
 636 0x00000000, 0x00000000, 0x00000003, 0x00000002, 0x00000c8b, 0x00000c95, 0x00000c9f, 0x00000c8c,
 637 0x00000c96, 0x00000ca0, 0x00000004, 0x00323369, 0x00000002, 0x00000002, 0x00000328, 0x00000000,
 638 0x00000000, 0x00000003, 0x00000003, 0x00000cef, 0x00000cf9, 0x00000d03, 0x00000cf0, 0x00000cfa,
 639 0x00000d04, 0x00000cf1, 0x00000cfb, 0x00000d05, 0x00000004, 0x00333369, 0x00000002, 0x00000002,
 640 0x0000037c, 0x00000000, 0x00000000, 0x00000003, 0x00000004, 0x00000d53, 0x00000d5d, 0x00000d67,
 641 0x00000d54, 0x00000d5e, 0x00000d68, 0x00000d55, 0x00000d5f, 0x00000d69, 0x00000d56, 0x00000d60,
 642 0x00000d6a, 0x00000004, 0x00343369, 0x00000002, 0x00000002, 0x000003b0, 0x00000000, 0x00000000,
 643 0x00000004, 0x00000001, 0x0000100f, 0x00001019, 0x00001023, 0x0000102d, 0x00000004, 0x00313469,
 644 0x00000002, 0x00000002, 0x000003f4, 0x00000000, 0x00000000, 0x00000004, 0x00000002, 0x00001073,
 645 0x0000107d, 0x00001087, 0x00001091, 0x00001074, 0x0000107e, 0x00001088, 0x00001092, 0x00000004,
 646 0x00323469, 0x00000002, 0x00000002, 0x00000448, 0x00000000, 0x00000000, 0x00000004, 0x00000003,
 647 0x000010d7, 0x000010e1, 0x000010eb, 0x000010f5, 0x000010d8, 0x000010e2, 0x000010ec, 0x000010f6,
 648 0x000010d9, 0x000010e3, 0x000010ed, 0x000010f7, 0x00000004, 0x00333469, 0x00000002, 0x00000002,
 649 0x000004ac, 0x00000000, 0x00000000, 0x00000004, 0x00000004, 0x0000113b, 0x00001145, 0x0000114f,
 650 0x00001159, 0x0000113c, 0x00001146, 0x00001150, 0x0000115a, 0x0000113d, 0x00001147, 0x00001151,
 651 0x0000115b, 0x0000113e, 0x00001148, 0x00001152, 0x0000115c, 0x00000004, 0x00343469, 0x00000002,
 652 0x00000000, 0x000004d8, 0x00000000, 0x00000002, 0x00000001, 0x00000001, 0x00000041, 0x00000042,
 653 0x00000004, 0x00325f69, 0x00000002, 0x00000001, 0x00000504, 0x00000000, 0x00000002, 0x00000001,
 654 0x00000001, 0x0000044d, 0x0000044e, 0x00000005, 0x325f3169, 0x00000000, 0x00000002, 0x00000001,
 655 0x0000053c, 0x00000000, 0x00000002, 0x00000002, 0x00000001, 0x00000835, 0x00000899, 0x00000836,
 656 0x0000089a, 0x00000005, 0x325f3269, 0x00000000, 0x00000002, 0x00000001, 0x0000057c, 0x00000000,
 657 0x00000002, 0x00000003, 0x00000001, 0x00000c1d, 0x00000c81, 0x00000ce5, 0x00000c1e, 0x00000c82,
 658 0x00000ce6, 0x00000005, 0x325f3369, 0x00000000, 0x00000002, 0x00000001, 0x000005c4, 0x00000000,
 659 0x00000002, 0x00000004, 0x00000001, 0x00001005, 0x00001069, 0x000010cd, 0x00001131, 0x00001006,
 660 0x0000106a, 0x000010ce, 0x00001132, 0x00000005, 0x325f3469, 0x00000000, 0x00000002, 0x00000002,
 661 0x000005f4, 0x00000000, 0x00000002, 0x00000001, 0x00000001, 0x00002b5d, 0x00002b5e, 0x00000006,
 662 0x5f313169, 0x00000032, 0x00000002, 0x00000002, 0x0000062c, 0x00000000, 0x00000002, 0x00000001,
 663 0x00000002, 0x00002f45, 0x00002fa9, 0x00002f46, 0x00002faa, 0x00000006, 0x5f323169, 0x00000032,
 664 0x00000002, 0x00000002, 0x0000066c, 0x00000000, 0x00000002, 0x00000001, 0x00000003, 0x0000332d,
 665 0x00003391, 0x000033f5, 0x0000332e, 0x00003392, 0x000033f6, 0x00000006, 0x5f333169, 0x00000032,
 666 0x00000002, 0x00000002, 0x000006b4, 0x00000000, 0x00000002, 0x00000001, 0x00000004, 0x00003715,
 667 0x00003779, 0x000037dd, 0x00003841, 0x00003716, 0x0000377a, 0x000037de, 0x00003842, 0x00000006,
 668 0x5f343169, 0x00000032, 0x00000002, 0x00000002, 0x000006ec, 0x00000000, 0x00000002, 0x00000002,
 669 0x00000001, 0x0003389d, 0x00033c85, 0x0003389e, 0x00033c86, 0x00000006, 0x5f313269, 0x00000032,
 670 0x00000002, 0x00000002, 0x00000734, 0x00000000, 0x00000002, 0x00000002, 0x00000002, 0x00035fad,
 671 0x00036395, 0x00036011, 0x000363f9, 0x00035fae, 0x00036396, 0x00036012, 0x000363fa, 0x00000006,
 672 0x5f323269, 0x00000032, 0x00000002, 0x00000002, 0x0000078c, 0x00000000, 0x00000002, 0x00000002,
 673 0x00000003, 0x000386bd, 0x00038aa5, 0x00038721, 0x00038b09, 0x00038785, 0x00038b6d, 0x000386be,
 674 0x00038aa6, 0x00038722, 0x00038b0a, 0x00038786, 0x00038b6e, 0x00000006, 0x5f333269, 0x00000032,
 675 0x00000002, 0x00000002, 0x000007f4, 0x00000000, 0x00000002, 0x00000002, 0x00000004, 0x0003adcd,
 676 0x0003b1b5, 0x0003ae31, 0x0003b219, 0x0003ae95, 0x0003b27d, 0x0003aef9, 0x0003b2e1, 0x0003adce,
 677 0x0003b1b6, 0x0003ae32, 0x0003b21a, 0x0003ae96, 0x0003b27e, 0x0003aefa, 0x0003b2e2, 0x00000006,
 678 0x5f343269, 0x00000032, 0x00000002, 0x00000002, 0x00000834, 0x00000000, 0x00000002, 0x00000003,
 679 0x00000001, 0x0004bf3d, 0x0004c325, 0x0004c70d, 0x0004bf3e, 0x0004c326, 0x0004c70e, 0x00000006,
 680 0x5f313369, 0x00000032, 0x00000002, 0x00000002, 0x0000088c, 0x00000000, 0x00000002, 0x00000003,
 681 0x00000002, 0x0004e64d, 0x0004ea35, 0x0004ee1d, 0x0004e6b1, 0x0004ea99, 0x0004ee81, 0x0004e64e,
 682 0x0004ea36, 0x0004ee1e, 0x0004e6b2, 0x0004ea9a, 0x0004ee82, 0x00000006, 0x5f323369, 0x00000032,
 683 0x00000002, 0x00000002, 0x000008fc, 0x00000000, 0x00000002, 0x00000003, 0x00000003, 0x00050d5d,
 684 0x00051145, 0x0005152d, 0x00050dc1, 0x000511a9, 0x00051591, 0x00050e25, 0x0005120d, 0x000515f5,
 685 0x00050d5e, 0x00051146, 0x0005152e, 0x00050dc2, 0x000511aa, 0x00051592, 0x00050e26, 0x0005120e,
 686 0x000515f6, 0x00000006, 0x5f333369, 0x00000032, 0x00000002, 0x00000002, 0x00000984, 0x00000000,
 687 0x00000002, 0x00000003, 0x00000004, 0x0005346d, 0x00053855, 0x00053c3d, 0x000534d1, 0x000538b9,
 688 0x00053ca1, 0x00053535, 0x0005391d, 0x00053d05, 0x00053599, 0x00053981, 0x00053d69, 0x0005346e,
 689 0x00053856, 0x00053c3e, 0x000534d2, 0x000538ba, 0x00053ca2, 0x00053536, 0x0005391e, 0x00053d06,
 690 0x0005359a, 0x00053982, 0x00053d6a, 0x00000006, 0x5f343369, 0x00000032, 0x00000002, 0x00000002,
 691 0x000009cc, 0x00000000, 0x00000002, 0x00000004, 0x00000001, 0x000645dd, 0x000649c5, 0x00064dad,
 692 0x00065195, 0x000645de, 0x000649c6, 0x00064dae, 0x00065196, 0x00000006, 0x5f313469, 0x00000032,
 693 0x00000002, 0x00000002, 0x00000a34, 0x00000000, 0x00000002, 0x00000004, 0x00000002, 0x00066ced,
 694 0x000670d5, 0x000674bd, 0x000678a5, 0x00066d51, 0x00067139, 0x00067521, 0x00067909, 0x00066cee,
 695 0x000670d6, 0x000674be, 0x000678a6, 0x00066d52, 0x0006713a, 0x00067522, 0x0006790a, 0x00000006,
 696 0x5f323469, 0x00000032, 0x00000002, 0x00000002, 0x00000abc, 0x00000000, 0x00000002, 0x00000004,
 697 0x00000003, 0x000693fd, 0x000697e5, 0x00069bcd, 0x00069fb5, 0x00069461, 0x00069849, 0x00069c31,
 698 0x0006a019, 0x000694c5, 0x000698ad, 0x00069c95, 0x0006a07d, 0x000693fe, 0x000697e6, 0x00069bce,
 699 0x00069fb6, 0x00069462, 0x0006984a, 0x00069c32, 0x0006a01a, 0x000694c6, 0x000698ae, 0x00069c96,
 700 0x0006a07e, 0x00000006, 0x5f333469, 0x00000032, 0x00000002, 0x00000002, 0x00000b64, 0x00000000,
 701 0x00000002, 0x00000004, 0x00000004, 0x0006bb0d, 0x0006bef5, 0x0006c2dd, 0x0006c6c5, 0x0006bb71,
 702 0x0006bf59, 0x0006c341, 0x0006c729, 0x0006bbd5, 0x0006bfbd, 0x0006c3a5, 0x0006c78d, 0x0006bc39,
 703 0x0006c021, 0x0006c409, 0x0006c7f1, 0x0006bb0e, 0x0006bef6, 0x0006c2de, 0x0006c6c6, 0x0006bb72,
 704 0x0006bf5a, 0x0006c342, 0x0006c72a, 0x0006bbd6, 0x0006bfbe, 0x0006c3a6, 0x0006c78e, 0x0006bc3a,
 705 0x0006c022, 0x0006c40a, 0x0006c7f2, 0x00000006, 0x5f343469, 0x00000032, 0x00000002, 0x00000070,
 706 0x00000002, 0x00000074, 0x0000002a, 0x00000001, 0x00000001, 0x00000001, 0x00000004, 0x00000020,
 707 0x00000000, 0x00000000, 0x0000002c, 0x00000048, 0x00000000, 0x00000000, 0x00000054, 0x00000070,
 708 0x00000000, 0x00000000, 0x00000080, 0x0000009c, 0x00000000, 0x00000000, 0x000000b0, 0x000000cc,
 709 0x00000000, 0x00000000, 0x000000e4, 0x00000100, 0x00000000, 0x00000000, 0x0000010c, 0x00000128,
 710 0x00000000, 0x00000000, 0x00000138, 0x00000154, 0x00000000, 0x00000000, 0x00000168, 0x00000184,
 711 0x00000000, 0x00000000, 0x0000019c, 0x000001b8, 0x00000000, 0x00000000, 0x000001c8, 0x000001e4,
 712 0x00000000, 0x00000000, 0x000001fc, 0x00000218, 0x00000000, 0x00000000, 0x00000238, 0x00000254,
 713 0x00000000, 0x00000000, 0x0000027c, 0x00000298, 0x00000000, 0x00000000, 0x000002ac, 0x000002c8,
 714 0x00000000, 0x00000000, 0x000002e8, 0x00000304, 0x00000000, 0x00000000, 0x00000330, 0x0000034c,
 715 0x00000000, 0x00000000, 0x00000384, 0x000003a0, 0x00000000, 0x00000000, 0x000003b8, 0x000003d4,
 716 0x00000000, 0x00000000, 0x000003fc, 0x00000418, 0x00000000, 0x00000000, 0x00000450, 0x0000046c,
 717 0x00000000, 0x00000000, 0x000004b4, 0x000004d0, 0x00000000, 0x00000000, 0x000004e0, 0x000004fc,
 718 0x00000000, 0x00000000, 0x00000510, 0x0000052c, 0x00000000, 0x00000000, 0x00000548, 0x00000564,
 719 0x00000000, 0x00000000, 0x00000588, 0x000005a4, 0x00000000, 0x00000000, 0x000005d0, 0x000005ec,
 720 0x00000000, 0x00000000, 0x00000600, 0x0000061c, 0x00000000, 0x00000000, 0x00000638, 0x00000654,
 721 0x00000000, 0x00000000, 0x00000678, 0x00000694, 0x00000000, 0x00000000, 0x000006c0, 0x000006dc,
 722 0x00000000, 0x00000000, 0x000006f8, 0x00000714, 0x00000000, 0x00000000, 0x00000740, 0x0000075c,
 723 0x00000000, 0x00000000, 0x00000798, 0x000007b4, 0x00000000, 0x00000000, 0x00000800, 0x0000081c,
 724 0x00000000, 0x00000000, 0x00000840, 0x0000085c, 0x00000000, 0x00000000, 0x00000898, 0x000008b4,
 725 0x00000000, 0x00000000, 0x00000908, 0x00000924, 0x00000000, 0x00000000, 0x00000990, 0x000009ac,
 726 0x00000000, 0x00000000, 0x000009d8, 0x000009f4, 0x00000000, 0x00000000, 0x00000a40, 0x00000a5c,
 727 0x00000000, 0x00000000, 0x00000ac8, 0x00000ae4, 0x00000000, 0x00000000, 0x00000b78, 0x00000000,
 728 0x00000001, 0x00000b70, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
 729 };
 730
 731 struct test_effect_parameter_value_result test_effect_parameter_value_result_int[] =
 732 {
 733     {"i",     {"i",     NULL, D3DXPC_SCALAR,      D3DXPT_INT, 1, 1, 0, 0, 0, 0,   4},  10},
 734     {"i1",    {"i1",    NULL, D3DXPC_VECTOR,      D3DXPT_INT, 1, 1, 0, 0, 0, 0,   4},  20},
 735     {"i2",    {"i2",    NULL, D3DXPC_VECTOR,      D3DXPT_INT, 1, 2, 0, 0, 0, 0,   8},  30},
 736     {"i3",    {"i3",    NULL, D3DXPC_VECTOR,      D3DXPT_INT, 1, 3, 0, 0, 0, 0,  12},  41},
 737     {"i4",    {"i4",    NULL, D3DXPC_VECTOR,      D3DXPT_INT, 1, 4, 0, 0, 0, 0,  16},  53},
 738     {"i11",   {"i11",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 1, 1, 0, 0, 0, 0,   4},  66},
 739     {"i12",   {"i12",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 1, 2, 0, 0, 0, 0,   8},  76},
 740     {"i13",   {"i13",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 1, 3, 0, 0, 0, 0,  12},  87},
 741     {"i14",   {"i14",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 1, 4, 0, 0, 0, 0,  16},  99},
 742     {"i21",   {"i21",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 2, 1, 0, 0, 0, 0,   8}, 112},
 743     {"i22",   {"i22",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 2, 2, 0, 0, 0, 0,  16}, 123},
 744     {"i23",   {"i23",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 2, 3, 0, 0, 0, 0,  24}, 136},
 745     {"i24",   {"i24",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 2, 4, 0, 0, 0, 0,  32}, 151},
 746     {"i31",   {"i31",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 3, 1, 0, 0, 0, 0,  12}, 168},
 747     {"i32",   {"i32",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 3, 2, 0, 0, 0, 0,  24}, 180},
 748     {"i33",   {"i33",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 3, 3, 0, 0, 0, 0,  36}, 195},
 749     {"i34",   {"i34",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 3, 4, 0, 0, 0, 0,  48}, 213},
 750     {"i41",   {"i41",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 4, 1, 0, 0, 0, 0,  16}, 234},
 751     {"i42",   {"i42",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 4, 2, 0, 0, 0, 0,  32}, 247},
 752     {"i43",   {"i43",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 4, 3, 0, 0, 0, 0,  48}, 264},
 753     {"i44",   {"i44",   NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 4, 4, 0, 0, 0, 0,  64}, 285},
 754     {"i_2",   {"i_2",   NULL, D3DXPC_SCALAR,      D3DXPT_INT, 1, 1, 2, 0, 0, 0,   8}, 310},
 755     {"i1_2",  {"i1_2",  NULL, D3DXPC_VECTOR,      D3DXPT_INT, 1, 1, 2, 0, 0, 0,   8}, 321},
 756     {"i2_2",  {"i2_2",  NULL, D3DXPC_VECTOR,      D3DXPT_INT, 1, 2, 2, 0, 0, 0,  16}, 333},
 757     {"i3_2",  {"i3_2",  NULL, D3DXPC_VECTOR,      D3DXPT_INT, 1, 3, 2, 0, 0, 0,  24}, 347},
 758     {"i4_2",  {"i4_2",  NULL, D3DXPC_VECTOR,      D3DXPT_INT, 1, 4, 2, 0, 0, 0,  32}, 363},
 759     {"i11_2", {"i11_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 1, 1, 2, 0, 0, 0,   8}, 381},
 760     {"i12_2", {"i12_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 1, 2, 2, 0, 0, 0,  16}, 393},
 761     {"i13_2", {"i13_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 1, 3, 2, 0, 0, 0,  24}, 407},
 762     {"i14_2", {"i14_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 1, 4, 2, 0, 0, 0,  32}, 423},
 763     {"i21_2", {"i21_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 2, 1, 2, 0, 0, 0,  16}, 441},
 764     {"i22_2", {"i22_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 2, 2, 2, 0, 0, 0,  32}, 455},
 765     {"i23_2", {"i23_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 2, 3, 2, 0, 0, 0,  48}, 473},
 766     {"i24_2", {"i24_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 2, 4, 2, 0, 0, 0,  64}, 495},
 767     {"i31_2", {"i31_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 3, 1, 2, 0, 0, 0,  24}, 521},
 768     {"i32_2", {"i32_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 3, 2, 2, 0, 0, 0,  48}, 537},
 769     {"i33_2", {"i33_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 3, 3, 2, 0, 0, 0,  72}, 559},
 770     {"i34_2", {"i34_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 3, 4, 2, 0, 0, 0,  96}, 587},
 771     {"i41_2", {"i41_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 4, 1, 2, 0, 0, 0,  32}, 621},
 772     {"i42_2", {"i42_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 4, 2, 2, 0, 0, 0,  64}, 639},
 773     {"i43_2", {"i43_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 4, 3, 2, 0, 0, 0,  96}, 665},
 774     {"i44_2", {"i44_2", NULL, D3DXPC_MATRIX_ROWS, D3DXPT_INT, 4, 4, 2, 0, 0, 0, 128}, 699},
 775 };
 776
 777 /*
 778  * fxc.exe /Tfx_2_0
 779  */
 780 #if 0
 781 string s = "test";
 782 string s_2[2] = {"test1", "test2"};
 783 texture2D tex;
 784 Vertexshader v;
 785 Vertexshader v_2[2];
 786 Pixelshader p;
 787 Pixelshader p_2[2];
 788 technique t { pass p { } }
 789 #endif
 790 static const DWORD test_effect_parameter_value_blob_object[] =
 791 {
 792 0xfeff0901, 0x00000100, 0x00000000, 0x00000004, 0x00000004, 0x0000001c, 0x00000000, 0x00000000,
 793 0x00000001, 0x00000002, 0x00000073, 0x00000004, 0x00000004, 0x00000040, 0x00000000, 0x00000002,
 794 0x00000002, 0x00000003, 0x00000004, 0x00325f73, 0x00000007, 0x00000004, 0x00000060, 0x00000000,
 795 0x00000000, 0x00000004, 0x00000004, 0x00786574, 0x00000010, 0x00000004, 0x00000080, 0x00000000,
 796 0x00000000, 0x00000005, 0x00000002, 0x00000076, 0x00000010, 0x00000004, 0x000000a4, 0x00000000,
 797 0x00000002, 0x00000006, 0x00000007, 0x00000004, 0x00325f76, 0x0000000f, 0x00000004, 0x000000c4,
 798 0x00000000, 0x00000000, 0x00000008, 0x00000002, 0x00000070, 0x0000000f, 0x00000004, 0x000000e8,
 799 0x00000000, 0x00000002, 0x00000009, 0x0000000a, 0x00000004, 0x00325f70, 0x00000002, 0x00000070,
 800 0x00000002, 0x00000074, 0x00000007, 0x00000001, 0x00000007, 0x0000000b, 0x00000004, 0x00000018,
 801 0x00000000, 0x00000000, 0x00000024, 0x00000038, 0x00000000, 0x00000000, 0x00000048, 0x0000005c,
 802 0x00000000, 0x00000000, 0x00000068, 0x0000007c, 0x00000000, 0x00000000, 0x00000088, 0x0000009c,
 803 0x00000000, 0x00000000, 0x000000ac, 0x000000c0, 0x00000000, 0x00000000, 0x000000cc, 0x000000e0,
 804 0x00000000, 0x00000000, 0x000000f8, 0x00000000, 0x00000001, 0x000000f0, 0x00000000, 0x00000000,
 805 0x0000000a, 0x00000000, 0x00000009, 0x00000000, 0x0000000a, 0x00000000, 0x00000008, 0x00000000,
 806 0x00000006, 0x00000000, 0x00000007, 0x00000000, 0x00000005, 0x00000000, 0x00000004, 0x00000000,
 807 0x00000002, 0x00000006, 0x74736574, 0x00000031, 0x00000003, 0x00000006, 0x74736574, 0x00000032,
 808 0x00000001, 0x00000005, 0x74736574, 0x00000000,
 809 };
 810
 811 struct test_effect_parameter_value_result test_effect_parameter_value_result_object[] =
 812 {
 813     {"s",     {"s",     NULL, D3DXPC_OBJECT, D3DXPT_STRING,       0, 0, 0, 0, 0, 0, sizeof(LPCSTR)},                      0},
 814     {"s_2",   {"s_2",   NULL, D3DXPC_OBJECT, D3DXPT_STRING,       0, 0, 2, 0, 0, 0, 2 * sizeof(LPCSTR)},                  0},
 815     {"tex",   {"tex",   NULL, D3DXPC_OBJECT, D3DXPT_TEXTURE2D,    0, 0, 0, 0, 0, 0, sizeof(LPDIRECT3DBASETEXTURE9)},      0},
 816     {"v",     {"v",     NULL, D3DXPC_OBJECT, D3DXPT_VERTEXSHADER, 0, 0, 0, 0, 0, 0, sizeof(LPDIRECT3DVERTEXSHADER9)},     0},
 817     {"v_2",   {"v_2",   NULL, D3DXPC_OBJECT, D3DXPT_VERTEXSHADER, 0, 0, 2, 0, 0, 0, 2 * sizeof(LPDIRECT3DVERTEXSHADER9)}, 0},
 818     {"p",     {"p",     NULL, D3DXPC_OBJECT, D3DXPT_PIXELSHADER,  0, 0, 0, 0, 0, 0, sizeof(LPDIRECT3DPIXELSHADER9)},      0},
 819     {"p_2",   {"p_2",   NULL, D3DXPC_OBJECT, D3DXPT_PIXELSHADER,  0, 0, 2, 0, 0, 0, 2 * sizeof(LPDIRECT3DPIXELSHADER9)},  0},
 820 };
 821
 822 /*
 823  * fxc.exe /Tfx_2_0
 824  */
 825 #if 0
 826 float3 f3 = {-3.1, 153.2, 283.3};
 827 float3 f3min = {-31.1, -31.2, -31.3};
 828 float3 f3max = {320.1, 320.2, 320.3};
 829 float4 f4 = {-4.1, 154.2, 284.3, 34.4};
 830 float4 f4min = {-41.1, -41.2, -41.3, -41.4};
 831 float4 f4max = {420.1, 42.20, 420.3, 420.4};
 832 technique t { pass p { } }
 833 #endif
 834 static const DWORD test_effect_parameter_value_blob_special[] =
 835 {
 836 0xfeff0901, 0x00000150, 0x00000000, 0x00000003, 0x00000001, 0x0000002c, 0x00000000, 0x00000000,
 837 0x00000003, 0x00000001, 0xc0466666, 0x43193333, 0x438da666, 0x00000003, 0x00003366, 0x00000003,
 838 0x00000001, 0x0000005c, 0x00000000, 0x00000000, 0x00000003, 0x00000001, 0xc1f8cccd, 0xc1f9999a,
 839 0xc1fa6666, 0x00000006, 0x696d3366, 0x0000006e, 0x00000003, 0x00000001, 0x00000090, 0x00000000,
 840 0x00000000, 0x00000003, 0x00000001, 0x43a00ccd, 0x43a0199a, 0x43a02666, 0x00000006, 0x616d3366,
 841 0x00000078, 0x00000003, 0x00000001, 0x000000c8, 0x00000000, 0x00000000, 0x00000004, 0x00000001,
 842 0xc0833333, 0x431a3333, 0x438e2666, 0x4209999a, 0x00000003, 0x00003466, 0x00000003, 0x00000001,
 843 0x000000fc, 0x00000000, 0x00000000, 0x00000004, 0x00000001, 0xc2246666, 0xc224cccd, 0xc2253333,
 844 0xc225999a, 0x00000006, 0x696d3466, 0x0000006e, 0x00000003, 0x00000001, 0x00000134, 0x00000000,
 845 0x00000000, 0x00000004, 0x00000001, 0x43d20ccd, 0x4228cccd, 0x43d22666, 0x43d23333, 0x00000006,
 846 0x616d3466, 0x00000078, 0x00000002, 0x00000070, 0x00000002, 0x00000074, 0x00000006, 0x00000001,
 847 0x00000001, 0x00000001, 0x00000004, 0x00000020, 0x00000000, 0x00000000, 0x00000034, 0x00000050,
 848 0x00000000, 0x00000000, 0x00000068, 0x00000084, 0x00000000, 0x00000000, 0x0000009c, 0x000000b8,
 849 0x00000000, 0x00000000, 0x000000d0, 0x000000ec, 0x00000000, 0x00000000, 0x00000108, 0x00000124,
 850 0x00000000, 0x00000000, 0x00000148, 0x00000000, 0x00000001, 0x00000140, 0x00000000, 0x00000000,
 851 0x00000000, 0x00000000,
 852 };
 853
 854 struct test_effect_parameter_value_result test_effect_parameter_value_result_special[] =
 855 {
 856     {"f3",    {"f3",    NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 3, 0, 0, 0, 0,  12},  10},
 857     {"f3min", {"f3min", NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 3, 0, 0, 0, 0,  12},  22},
 858     {"f3max", {"f3max", NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 3, 0, 0, 0, 0,  12},  35},
 859     {"f4",    {"f4",    NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 4, 0, 0, 0, 0,  16},  48},
 860     {"f4min", {"f4min", NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 4, 0, 0, 0, 0,  16},  61},
 861     {"f4max", {"f4max", NULL, D3DXPC_VECTOR,      D3DXPT_FLOAT, 1, 4, 0, 0, 0, 0,  16},  75},
 862 };
 863
 864 #define ADD_PARAMETER_VALUE(x) {\
 865     test_effect_parameter_value_blob_ ## x,\
 866     sizeof(test_effect_parameter_value_blob_ ## x),\
 867     test_effect_parameter_value_result_ ## x,\
 868     sizeof(test_effect_parameter_value_result_ ## x)/sizeof(*test_effect_parameter_value_result_ ## x),\
 869 }
 870
 871 static const struct
 872 {
 873     const DWORD *blob;
 874     UINT blob_size;
 875     const struct test_effect_parameter_value_result *res;
 876     UINT res_count;
 877 }
 878 test_effect_parameter_value_data[] =
 879 {
 880     ADD_PARAMETER_VALUE(float),
 881     ADD_PARAMETER_VALUE(int),
 882     ADD_PARAMETER_VALUE(object),
 883     ADD_PARAMETER_VALUE(special),
 884 };
 885
 886 #undef ADD_PARAMETER_VALUE
 887
 888 /* Multiple of 16 to cover complete matrices */
 889 #define EFFECT_PARAMETER_VALUE_ARRAY_SIZE 48
 890 /* Constants for special INT/FLOAT conversation */
 891 #define INT_FLOAT_MULTI 255.0f
 892 #define INT_FLOAT_MULTI_INVERSE (1/INT_FLOAT_MULTI)
 893
 894 static void test_effect_parameter_value_GetValue(const struct test_effect_parameter_value_result *res,
 895         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
 896 {
 897     const D3DXPARAMETER_DESC *res_desc = &res->desc;
 898     LPCSTR res_full_name = res->full_name;
 899     DWORD value[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
 900     HRESULT hr;
 901     UINT l;
 902
 903     memset(value, 0xab, sizeof(value));
 904     hr = effect->lpVtbl->GetValue(effect, parameter, value, res_desc->Bytes);
 905     if (res_desc->Class == D3DXPC_SCALAR
 906             || res_desc->Class == D3DXPC_VECTOR
 907             || res_desc->Class == D3DXPC_MATRIX_ROWS)
 908     {
 909         ok(hr == D3D_OK, "%u - %s: GetValue failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
 910
 911         for (l = 0; l < res_desc->Bytes / sizeof(*value); ++l)
 912         {
 913             ok(value[l] == res_value[l], "%u - %s: GetValue value[%u] failed, got %#x, expected %#x\n",
 914                     i, res_full_name, l, value[l], res_value[l]);
 915         }
 916
 917         for (l = res_desc->Bytes / sizeof(*value); l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
 918         {
 919             ok(value[l] == 0xabababab, "%u - %s: GetValue value[%u] failed, got %#x, expected %#x\n",
 920                     i, res_full_name, l, value[l], 0xabababab);
 921         }
 922     }
 923     else if (res_desc->Class == D3DXPC_OBJECT)
 924     {
 925         switch (res_desc->Type)
 926         {
 927             case D3DXPT_PIXELSHADER:
 928             case D3DXPT_VERTEXSHADER:
 929             case D3DXPT_TEXTURE2D:
 930                 ok(hr == D3D_OK, "%u - %s: GetValue failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
 931
 932                 for (l = 0; l < (res_desc->Elements ? res_desc->Elements : 1); ++l)
 933                 {
 934                     IUnknown *unk = *((IUnknown **)value + l);
 935                     if (unk) IUnknown_Release(unk);
 936                 }
 937                 break;
 938
 939             case D3DXPT_STRING:
 940                 ok(hr == D3D_OK, "%u - %s: GetValue failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
 941                 break;
 942
 943             default:
 944                 ok(0, "Type is %u, this should not happen!\n", res_desc->Type);
 945                 break;
 946         }
 947     }
 948     else
 949     {
 950         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetValue failed, got %#x, expected %#x\n",
 951                 i, res_full_name, hr, D3DERR_INVALIDCALL);
 952
 953         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
 954         {
 955             ok(value[l] == 0xabababab, "%u - %s: GetValue value[%u] failed, got %#x, expected %#x\n",
 956                     i, res_full_name, l, value[l], 0xabababab);
 957         }
 958     }
 959 }
 960
 961 static void test_effect_parameter_value_GetBool(const struct test_effect_parameter_value_result *res,
 962         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
 963 {
 964     const D3DXPARAMETER_DESC *res_desc = &res->desc;
 965     LPCSTR res_full_name = res->full_name;
 966     BOOL bvalue = 0xabababab;
 967     HRESULT hr;
 968
 969     hr = effect->lpVtbl->GetBool(effect, parameter, &bvalue);
 970     if (!res_desc->Elements && res_desc->Rows == 1 && res_desc->Columns == 1)
 971     {
 972         ok(hr == D3D_OK, "%u - %s: GetBool failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
 973         ok(bvalue == get_bool(res_value), "%u - %s: GetBool bvalue failed, got %#x, expected %#x\n",
 974                 i, res_full_name, bvalue, get_bool(res_value));
 975     }
 976     else
 977     {
 978         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetBool failed, got %#x, expected %#x\n",
 979                 i, res_full_name, hr, D3DERR_INVALIDCALL);
 980         ok(bvalue == 0xabababab, "%u - %s: GetBool bvalue failed, got %#x, expected %#x\n",
 981                 i, res_full_name, bvalue, 0xabababab);
 982     }
 983 }
 984
 985 static void test_effect_parameter_value_GetBoolArray(const struct test_effect_parameter_value_result *res,
 986         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
 987 {
 988     const D3DXPARAMETER_DESC *res_desc = &res->desc;
 989     LPCSTR res_full_name = res->full_name;
 990     BOOL bavalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
 991     HRESULT hr;
 992     UINT l;
 993
 994     memset(bavalue, 0xab, sizeof(bavalue));
 995     hr = effect->lpVtbl->GetBoolArray(effect, parameter, bavalue, res_desc->Bytes / sizeof(*bavalue));
 996     if (res_desc->Class == D3DXPC_SCALAR
 997             || res_desc->Class == D3DXPC_VECTOR
 998             || res_desc->Class == D3DXPC_MATRIX_ROWS)
 999     {
1000         ok(hr == D3D_OK, "%u - %s: GetBoolArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1001
1002         for (l = 0; l < res_desc->Bytes / sizeof(*bavalue); ++l)
1003         {
1004             ok(bavalue[l] == get_bool(&res_value[l]), "%u - %s: GetBoolArray bavalue[%u] failed, got %#x, expected %#x\n",
1005                     i, res_full_name, l, bavalue[l], get_bool(&res_value[l]));
1006         }
1007
1008         for (l = res_desc->Bytes / sizeof(*bavalue); l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1009         {
1010             ok(bavalue[l] == 0xabababab, "%u - %s: GetBoolArray bavalue[%u] failed, got %#x, expected %#x\n",
1011                     i, res_full_name, l, bavalue[l], 0xabababab);
1012         }
1013     }
1014     else
1015     {
1016         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetBoolArray failed, got %#x, expected %#x\n",
1017                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1018
1019         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1020         {
1021             ok(bavalue[l] == 0xabababab, "%u - %s: GetBoolArray bavalue[%u] failed, got %#x, expected %#x\n",
1022                     i, res_full_name, l, bavalue[l], 0xabababab);
1023         }
1024     }
1025 }
1026
1027 static void test_effect_parameter_value_GetInt(const struct test_effect_parameter_value_result *res,
1028         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1029 {
1030     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1031     LPCSTR res_full_name = res->full_name;
1032     INT ivalue = 0xabababab;
1033     HRESULT hr;
1034
1035     hr = effect->lpVtbl->GetInt(effect, parameter, &ivalue);
1036     if (!res_desc->Elements && res_desc->Columns == 1 && res_desc->Rows == 1)
1037     {
1038         ok(hr == D3D_OK, "%u - %s: GetInt failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1039         ok(ivalue == get_int(res_desc->Type, res_value), "%u - %s: GetInt ivalue failed, got %i, expected %i\n",
1040                 i, res_full_name, ivalue, get_int(res_desc->Type, res_value));
1041     }
1042     else if(!res_desc->Elements && res_desc->Type == D3DXPT_FLOAT &&
1043             ((res_desc->Class == D3DXPC_VECTOR && res_desc->Columns != 2) ||
1044             (res_desc->Class == D3DXPC_MATRIX_ROWS && res_desc->Rows != 2 && res_desc->Columns == 1)))
1045     {
1046         INT tmp;
1047
1048         ok(hr == D3D_OK, "%u - %s: GetInt failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1049
1050         tmp = (INT)(min(max(0.0f, *((FLOAT *)res_value + 2)), 1.0f) * INT_FLOAT_MULTI);
1051         tmp += ((INT)(min(max(0.0f, *((FLOAT *)res_value + 1)), 1.0f) * INT_FLOAT_MULTI)) << 8;
1052         tmp += ((INT)(min(max(0.0f, *((FLOAT *)res_value + 0)), 1.0f) * INT_FLOAT_MULTI)) << 16;
1053         if (res_desc->Columns * res_desc->Rows > 3)
1054         {
1055             tmp += ((INT)(min(max(0.0f, *((FLOAT *)res_value + 3)), 1.0f) * INT_FLOAT_MULTI)) << 24;
1056         }
1057
1058         ok(ivalue == tmp, "%u - %s: GetInt ivalue failed, got %x, expected %x\n",
1059                 i, res_full_name, ivalue, tmp);
1060     }
1061     else
1062     {
1063         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetInt failed, got %#x, expected %#x\n",
1064                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1065         ok(ivalue == 0xabababab, "%u - %s: GetInt ivalue failed, got %i, expected %i\n",
1066                 i, res_full_name, ivalue, 0xabababab);
1067     }
1068 }
1069
1070 static void test_effect_parameter_value_GetIntArray(const struct test_effect_parameter_value_result *res,
1071         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1072 {
1073     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1074     LPCSTR res_full_name = res->full_name;
1075     INT iavalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1076     HRESULT hr;
1077     UINT l;
1078
1079     memset(iavalue, 0xab, sizeof(iavalue));
1080     hr = effect->lpVtbl->GetIntArray(effect, parameter, iavalue, res_desc->Bytes / sizeof(*iavalue));
1081     if (res_desc->Class == D3DXPC_SCALAR
1082             || res_desc->Class == D3DXPC_VECTOR
1083             || res_desc->Class == D3DXPC_MATRIX_ROWS)
1084     {
1085         ok(hr == D3D_OK, "%u - %s: GetIntArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1086
1087         for (l = 0; l < res_desc->Bytes / sizeof(*iavalue); ++l)
1088         {
1089             ok(iavalue[l] == get_int(res_desc->Type, &res_value[l]), "%u - %s: GetIntArray iavalue[%u] failed, got %i, expected %i\n",
1090                     i, res_full_name, l, iavalue[l], get_int(res_desc->Type, &res_value[l]));
1091         }
1092
1093         for (l = res_desc->Bytes / sizeof(*iavalue); l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1094         {
1095             ok(iavalue[l] == 0xabababab, "%u - %s: GetIntArray iavalue[%u] failed, got %i, expected %i\n",
1096                     i, res_full_name, l, iavalue[l], 0xabababab);
1097         }
1098     }
1099     else
1100     {
1101         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetIntArray failed, got %#x, expected %#x\n",
1102                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1103
1104         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1105         {
1106             ok(iavalue[l] == 0xabababab, "%u - %s: GetIntArray iavalue[%u] failed, got %i, expected %i\n",
1107                     i, res_full_name, l, iavalue[l], 0xabababab);
1108         }
1109     }
1110 }
1111
1112 static void test_effect_parameter_value_GetFloat(const struct test_effect_parameter_value_result *res,
1113         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1114 {
1115     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1116     LPCSTR res_full_name = res->full_name;
1117     HRESULT hr;
1118     DWORD cmp = 0xabababab;
1119     FLOAT fvalue = *(FLOAT *)&cmp;
1120
1121     hr = effect->lpVtbl->GetFloat(effect, parameter, &fvalue);
1122     if (!res_desc->Elements && res_desc->Columns == 1 && res_desc->Rows == 1)
1123     {
1124         ok(hr == D3D_OK, "%u - %s: GetFloat failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1125         ok(compare_float(fvalue, get_float(res_desc->Type, res_value), 512), "%u - %s: GetFloat fvalue failed, got %f, expected %f\n",
1126                 i, res_full_name, fvalue, get_float(res_desc->Type, res_value));
1127     }
1128     else
1129     {
1130         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloat failed, got %#x, expected %#x\n",
1131                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1132         ok(fvalue == *(FLOAT *)&cmp, "%u - %s: GetFloat fvalue failed, got %f, expected %f\n",
1133                 i, res_full_name, fvalue, *(FLOAT *)&cmp);
1134     }
1135 }
1136
1137 static void test_effect_parameter_value_GetFloatArray(const struct test_effect_parameter_value_result *res,
1138         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1139 {
1140     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1141     LPCSTR res_full_name = res->full_name;
1142     FLOAT favalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1143     HRESULT hr;
1144     UINT l;
1145     DWORD cmp = 0xabababab;
1146
1147     memset(favalue, 0xab, sizeof(favalue));
1148     hr = effect->lpVtbl->GetFloatArray(effect, parameter, favalue, res_desc->Bytes / sizeof(*favalue));
1149     if (res_desc->Class == D3DXPC_SCALAR
1150             || res_desc->Class == D3DXPC_VECTOR
1151             || res_desc->Class == D3DXPC_MATRIX_ROWS)
1152     {
1153         ok(hr == D3D_OK, "%u - %s: GetFloatArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1154
1155         for (l = 0; l < res_desc->Bytes / sizeof(*favalue); ++l)
1156         {
1157             ok(compare_float(favalue[l], get_float(res_desc->Type, &res_value[l]), 512),
1158                     "%u - %s: GetFloatArray favalue[%u] failed, got %f, expected %f\n",
1159                     i, res_full_name, l, favalue[l], get_float(res_desc->Type, &res_value[l]));
1160         }
1161
1162         for (l = res_desc->Bytes / sizeof(*favalue); l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1163         {
1164             ok(favalue[l] == *(FLOAT *)&cmp, "%u - %s: GetFloatArray favalue[%u] failed, got %f, expected %f\n",
1165                     i, res_full_name, l, favalue[l], *(FLOAT *)&cmp);
1166         }
1167     }
1168     else
1169     {
1170         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloatArray failed, got %#x, expected %#x\n",
1171                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1172
1173         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1174         {
1175             ok(favalue[l] == *(FLOAT *)&cmp, "%u - %s: GetFloatArray favalue[%u] failed, got %f, expected %f\n",
1176                     i, res_full_name, l, favalue[l], *(FLOAT *)&cmp);
1177         }
1178     }
1179 }
1180
1181 static void test_effect_parameter_value_GetVector(const struct test_effect_parameter_value_result *res,
1182         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1183 {
1184     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1185     LPCSTR res_full_name = res->full_name;
1186     HRESULT hr;
1187     DWORD cmp = 0xabababab;
1188     FLOAT fvalue[4];
1189     UINT l;
1190
1191     memset(fvalue, 0xab, sizeof(fvalue));
1192     hr = effect->lpVtbl->GetVector(effect, parameter, (D3DXVECTOR4 *)&fvalue);
1193     if (!res_desc->Elements &&
1194             (res_desc->Class == D3DXPC_SCALAR || res_desc->Class == D3DXPC_VECTOR) &&
1195             res_desc->Type == D3DXPT_INT && res_desc->Bytes == 4)
1196     {
1197         DWORD tmp;
1198
1199         ok(hr == D3D_OK, "%u - %s: GetVector failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1200
1201         tmp = (DWORD)(*(fvalue + 2) * INT_FLOAT_MULTI);
1202         tmp += ((DWORD)(*(fvalue + 1) * INT_FLOAT_MULTI)) << 8;
1203         tmp += ((DWORD)(*fvalue * INT_FLOAT_MULTI)) << 16;
1204         tmp += ((DWORD)(*(fvalue + 3) * INT_FLOAT_MULTI)) << 24;
1205
1206         ok(*res_value == tmp, "%u - %s: GetVector ivalue failed, got %i, expected %i\n",
1207                 i, res_full_name, tmp, *res_value);
1208     }
1209     else if (!res_desc->Elements && (res_desc->Class == D3DXPC_SCALAR || res_desc->Class == D3DXPC_VECTOR))
1210     {
1211         ok(hr == D3D_OK, "%u - %s: GetVector failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1212
1213         for (l = 0; l < res_desc->Columns; ++l)
1214         {
1215             ok(compare_float(fvalue[l], get_float(res_desc->Type, &res_value[l]), 512),
1216                     "%u - %s: GetVector fvalue[%u] failed, got %f, expected %f\n",
1217                     i, res_full_name, l, fvalue[l], get_float(res_desc->Type, &res_value[l]));
1218         }
1219
1220         for (l = res_desc->Columns; l < 4; ++l)
1221         {
1222             ok(fvalue[l] == 0.0f, "%u - %s: GetVector fvalue[%u] failed, got %f, expected %f\n",
1223                     i, res_full_name, l, fvalue[l], 0.0f);
1224         }
1225     }
1226     else
1227     {
1228         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetVector failed, got %#x, expected %#x\n",
1229                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1230
1231         for (l = 0; l < 4; ++l)
1232         {
1233             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetVector fvalue[%u] failed, got %f, expected %f\n",
1234                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1235         }
1236     }
1237 }
1238
1239 static void test_effect_parameter_value_GetVectorArray(const struct test_effect_parameter_value_result *res,
1240         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1241 {
1242     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1243     LPCSTR res_full_name = res->full_name;
1244     HRESULT hr;
1245     DWORD cmp = 0xabababab;
1246     FLOAT fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1247     UINT l, k;
1248
1249     memset(fvalue, 0xab, sizeof(fvalue));
1250     hr = effect->lpVtbl->GetVectorArray(effect, parameter, (D3DXVECTOR4 *)&fvalue, res_desc->Elements);
1251     if (!res_desc->Elements)
1252     {
1253         ok(hr == D3D_OK, "%u - %s: GetVectorArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1254
1255         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1256         {
1257             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetVectorArray fvalue[%u] failed, got %f, expected %f\n",
1258                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1259         }
1260     }
1261     else if (res_desc->Elements && res_desc->Class == D3DXPC_VECTOR)
1262     {
1263         ok(hr == D3D_OK, "%u - %s: GetVectorArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1264
1265         for (k = 0; k < res_desc->Elements; ++k)
1266         {
1267             for (l = 0; l < res_desc->Columns; ++l)
1268             {
1269                 ok(compare_float(fvalue[l + k * 4], get_float(res_desc->Type, &res_value[ l + k * res_desc->Columns]), 512),
1270                         "%u - %s: GetVectorArray fvalue[%u] failed, got %f, expected %f\n",
1271                         i, res_full_name, l + k * 4, fvalue[ l + k * 4], get_float(res_desc->Type, &res_value[ l + k * res_desc->Columns]));
1272             }
1273
1274             for (l = res_desc->Columns; l < 4; ++l)
1275             {
1276                 ok(fvalue[ l + k * 4] == 0.0f, "%u - %s: GetVectorArray fvalue[%u] failed, got %f, expected %f\n",
1277                         i, res_full_name, l + k * 4, fvalue[ l + k * 4], 0.0f);
1278             }
1279         }
1280
1281         for (l = res_desc->Elements * 4; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1282         {
1283             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetVectorArray fvalue[%u] failed, got %f, expected %f\n",
1284                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1285         }
1286     }
1287     else
1288     {
1289         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetVectorArray failed, got %#x, expected %#x\n",
1290                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1291
1292         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1293         {
1294             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetVectorArray fvalue[%u] failed, got %f, expected %f\n",
1295                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1296         }
1297     }
1298 }
1299
1300 static void test_effect_parameter_value_GetMatrix(const struct test_effect_parameter_value_result *res,
1301         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1302 {
1303     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1304     LPCSTR res_full_name = res->full_name;
1305     HRESULT hr;
1306     DWORD cmp = 0xabababab;
1307     FLOAT fvalue[16];
1308     UINT l, k;
1309
1310     memset(fvalue, 0xab, sizeof(fvalue));
1311     hr = effect->lpVtbl->GetMatrix(effect, parameter, (D3DXMATRIX *)&fvalue);
1312     if (!res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1313     {
1314         ok(hr == D3D_OK, "%u - %s: GetMatrix failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1315
1316         for (k = 0; k < 4; ++k)
1317         {
1318             for (l = 0; l < 4; ++l)
1319             {
1320                 if (k < res_desc->Columns && l < res_desc->Rows)
1321                 {
1322                     ok(compare_float(fvalue[l * 4 + k], get_float(res_desc->Type, &res_value[l * res_desc->Columns + k]), 512),
1323                             "%u - %s: GetMatrix fvalue[%u] failed, got %f, expected %f\n",
1324                             i, res_full_name, l * 4 + k, fvalue[l * 4 + k],
1325                             get_float(res_desc->Type, &res_value[l * res_desc->Columns + k]));
1326                 }
1327                 else
1328                 {
1329                     ok(fvalue[l * 4 + k] == 0.0f, "%u - %s: GetMatrix fvalue[%u] failed, got %f, expected %f\n",
1330                             i, res_full_name, l * 4 + k, fvalue[l * 4 + k], 0.0f);
1331                 }
1332             }
1333         }
1334     }
1335     else
1336     {
1337         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrix failed, got %#x, expected %#x\n",
1338                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1339
1340         for (l = 0; l < sizeof(fvalue) / sizeof(*fvalue); ++l)
1341         {
1342             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrix fvalue[%u] failed, got %f, expected %f\n",
1343                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1344         }
1345     }
1346 }
1347
1348 static void test_effect_parameter_value_GetMatrixArray(const struct test_effect_parameter_value_result *res,
1349         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1350 {
1351     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1352     LPCSTR res_full_name = res->full_name;
1353     HRESULT hr;
1354     DWORD cmp = 0xabababab;
1355     FLOAT fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1356     UINT l, k, m;
1357
1358     memset(fvalue, 0xab, sizeof(fvalue));
1359     hr = effect->lpVtbl->GetMatrixArray(effect, parameter, (D3DXMATRIX *)&fvalue, res_desc->Elements);
1360     if (!res_desc->Elements)
1361     {
1362         ok(hr == D3D_OK, "%u - %s: GetMatrixArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1363
1364         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1365         {
1366             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixArray fvalue[%u] failed, got %f, expected %f\n",
1367                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1368         }
1369     }
1370     else if (res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1371     {
1372         ok(hr == D3D_OK, "%u - %s: GetMatrixArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1373
1374         for (m = 0; m < res_desc->Elements; ++m)
1375         {
1376             for (k = 0; k < 4; ++k)
1377             {
1378                 for (l = 0; l < 4; ++l)
1379                 {
1380                     if (k < res_desc->Columns && l < res_desc->Rows)
1381                     {
1382                         ok(compare_float(fvalue[m * 16 + l * 4 + k], get_float(res_desc->Type,
1383                                 &res_value[m * res_desc->Columns * res_desc->Rows + l * res_desc->Columns + k]), 512),
1384                                 "%u - %s: GetMatrixArray fvalue[%u] failed, got %f, expected %f\n",
1385                                 i, res_full_name, m * 16 + l * 4 + k, fvalue[m * 16 + l * 4 + k],
1386                                 get_float(res_desc->Type, &res_value[m * res_desc->Columns * res_desc->Rows
1387                                 + l * res_desc->Columns + k]));
1388                     }
1389                     else
1390                     {
1391                         ok(fvalue[m * 16 + l * 4 + k] == 0.0f, "%u - %s: GetMatrixArray fvalue[%u] failed, got %f, expected %f\n",
1392                                 i, res_full_name, m * 16 + l * 4 + k, fvalue[m * 16 + l * 4 + k], 0.0f);
1393                     }
1394                 }
1395             }
1396         }
1397
1398         for (l = res_desc->Elements * 16; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1399         {
1400             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixArray fvalue[%u] failed, got %f, expected %f\n",
1401                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1402         }
1403     }
1404     else
1405     {
1406         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixArray failed, got %#x, expected %#x\n",
1407                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1408
1409         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1410         {
1411             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixArray fvalue[%u] failed, got %f, expected %f\n",
1412                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1413         }
1414     }
1415 }
1416
1417 static void test_effect_parameter_value_GetMatrixPointerArray(const struct test_effect_parameter_value_result *res,
1418         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1419 {
1420     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1421     LPCSTR res_full_name = res->full_name;
1422     HRESULT hr;
1423     DWORD cmp = 0xabababab;
1424     FLOAT fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1425     D3DXMATRIX *matrix_pointer_array[sizeof(fvalue)/sizeof(D3DXMATRIX)];
1426     UINT l, k, m, element;
1427
1428     for (element = 0; element <= res_desc->Elements + 1; ++element)
1429     {
1430         memset(fvalue, 0xab, sizeof(fvalue));
1431         for (l = 0; l < element; ++l)
1432         {
1433             matrix_pointer_array[l] = (D3DXMATRIX *)&fvalue[l * sizeof(**matrix_pointer_array) / sizeof(FLOAT)];
1434         }
1435         hr = effect->lpVtbl->GetMatrixPointerArray(effect, parameter, matrix_pointer_array, element);
1436         if (!element)
1437         {
1438             ok(hr == D3D_OK, "%u - %s: GetMatrixPointerArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1439
1440             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1441             {
1442                 ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixPointerArray fvalue[%u] failed, got %f, expected %f\n",
1443                         i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1444             }
1445         }
1446         else if (element <= res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1447         {
1448             ok(hr == D3D_OK, "%u - %s: GetMatrixPointerArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1449
1450             for (m = 0; m < element; ++m)
1451             {
1452                 for (k = 0; k < 4; ++k)
1453                 {
1454                     for (l = 0; l < 4; ++l)
1455                     {
1456                         if (k < res_desc->Columns && l < res_desc->Rows)
1457                         {
1458                             ok(compare_float(fvalue[m * 16 + l * 4 + k], get_float(res_desc->Type,
1459                                     &res_value[m * res_desc->Columns * res_desc->Rows + l * res_desc->Columns + k]), 512),
1460                                     "%u - %s: GetMatrixPointerArray fvalue[%u] failed, got %f, expected %f\n",
1461                                     i, res_full_name, m * 16 + l * 4 + k, fvalue[m * 16 + l * 4 + k],
1462                                     get_float(res_desc->Type, &res_value[m * res_desc->Columns * res_desc->Rows
1463                                     + l * res_desc->Columns + k]));
1464                         }
1465                         else
1466                         {
1467                             ok(fvalue[m * 16 + l * 4 + k] == 0.0f, "%u - %s: GetMatrixPointerArray fvalue[%u] failed, got %f, expected %f\n",
1468                                     i, res_full_name, m * 16 + l * 4 + k, fvalue[m * 16 + l * 4 + k], 0.0f);
1469                         }
1470                     }
1471                 }
1472             }
1473
1474             for (l = element * 16; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1475             {
1476                 ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixPointerArray fvalue[%u] failed, got %f, expected %f\n",
1477                         i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1478             }
1479         }
1480         else
1481         {
1482             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixPointerArray failed, got %#x, expected %#x\n",
1483                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1484
1485             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1486             {
1487                 ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixPointerArray fvalue[%u] failed, got %f, expected %f\n",
1488                         i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1489             }
1490         }
1491     }
1492 }
1493
1494 static void test_effect_parameter_value_GetMatrixTranspose(const struct test_effect_parameter_value_result *res,
1495         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1496 {
1497     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1498     LPCSTR res_full_name = res->full_name;
1499     HRESULT hr;
1500     DWORD cmp = 0xabababab;
1501     FLOAT fvalue[16];
1502     UINT l, k;
1503
1504     memset(fvalue, 0xab, sizeof(fvalue));
1505     hr = effect->lpVtbl->GetMatrixTranspose(effect, parameter, (D3DXMATRIX *)&fvalue);
1506     if (!res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1507     {
1508         ok(hr == D3D_OK, "%u - %s: GetMatrixTranspose failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1509
1510         for (k = 0; k < 4; ++k)
1511         {
1512             for (l = 0; l < 4; ++l)
1513             {
1514                 if (k < res_desc->Columns && l < res_desc->Rows)
1515                 {
1516                     ok(compare_float(fvalue[l + k * 4], get_float(res_desc->Type, &res_value[l * res_desc->Columns + k]), 512),
1517                             "%u - %s: GetMatrixTranspose fvalue[%u] failed, got %f, expected %f\n",
1518                             i, res_full_name, l + k * 4, fvalue[l + k * 4],
1519                             get_float(res_desc->Type, &res_value[l * res_desc->Columns + k]));
1520                 }
1521                 else
1522                 {
1523                     ok(fvalue[l + k * 4] == 0.0f, "%u - %s: GetMatrixTranspose fvalue[%u] failed, got %f, expected %f\n",
1524                             i, res_full_name, l + k * 4, fvalue[l + k * 4], 0.0f);
1525                 }
1526             }
1527         }
1528     }
1529     else if (!res_desc->Elements && (res_desc->Class == D3DXPC_VECTOR || res_desc->Class == D3DXPC_SCALAR))
1530     {
1531         ok(hr == D3D_OK, "%u - %s: GetMatrixTranspose failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1532
1533         for (k = 0; k < 4; ++k)
1534         {
1535             for (l = 0; l < 4; ++l)
1536             {
1537                 if (k < res_desc->Columns && l < res_desc->Rows)
1538                 {
1539                     FLOAT res = get_float(res_desc->Type, &res_value[l * res_desc->Columns + k]);
1540
1541                     ok(fvalue[l * 4 + k] == res, "%u - %s: GetMatrixTranspose fvalue[%u] failed, got %f, expected %f\n",
1542                             i, res_full_name, l * 4 + k, fvalue[l * 4 + k], res);
1543                 }
1544                 else
1545                 {
1546                     ok(fvalue[l * 4 + k] == 0.0f, "%u - %s: GetMatrixTranspose fvalue[%u] failed, got %f, expected %f\n",
1547                             i, res_full_name, l * 4 + k, fvalue[l * 4 + k], 0.0f);
1548                 }
1549             }
1550         }
1551     }
1552     else
1553     {
1554         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTranspose failed, got %#x, expected %#x\n",
1555                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1556
1557         for (l = 0; l < sizeof(fvalue) / sizeof(*fvalue); ++l)
1558         {
1559             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixTranspose fvalue[%u] failed, got %f, expected %f\n",
1560                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1561         }
1562     }
1563 }
1564
1565 static void test_effect_parameter_value_GetMatrixTransposeArray(const struct test_effect_parameter_value_result *res,
1566         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1567 {
1568     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1569     LPCSTR res_full_name = res->full_name;
1570     HRESULT hr;
1571     DWORD cmp = 0xabababab;
1572     FLOAT fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1573     UINT l, k, m;
1574
1575     memset(fvalue, 0xab, sizeof(fvalue));
1576     hr = effect->lpVtbl->GetMatrixTransposeArray(effect, parameter, (D3DXMATRIX *)&fvalue, res_desc->Elements);
1577     if (!res_desc->Elements)
1578     {
1579         ok(hr == D3D_OK, "%u - %s: GetMatrixTransposeArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1580
1581         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1582         {
1583             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixTransposeArray fvalue[%u] failed, got %f, expected %f\n",
1584                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1585         }
1586     }
1587     else if (res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1588     {
1589         ok(hr == D3D_OK, "%u - %s: GetMatrixTransposeArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1590
1591         for (m = 0; m < res_desc->Elements; ++m)
1592         {
1593             for (k = 0; k < 4; ++k)
1594             {
1595                 for (l = 0; l < 4; ++l)
1596                 {
1597                     if (k < res_desc->Columns && l < res_desc->Rows)
1598                     {
1599                         ok(compare_float(fvalue[m * 16 + l + k * 4], get_float(res_desc->Type,
1600                                 &res_value[m * res_desc->Columns * res_desc->Rows + l * res_desc->Columns + k]), 512),
1601                                 "%u - %s: GetMatrixTransposeArray fvalue[%u] failed, got %f, expected %f\n",
1602                                 i, res_full_name, m * 16 + l + k * 4, fvalue[m * 16 + l + k * 4],
1603                                 get_float(res_desc->Type, &res_value[m * res_desc->Columns * res_desc->Rows
1604                                 + l * res_desc->Columns + k]));
1605                     }
1606                     else
1607                     {
1608                         ok(fvalue[m * 16 + l + k * 4] == 0.0f, "%u - %s: GetMatrixTransposeArray fvalue[%u] failed, got %f, expected %f\n",
1609                                 i, res_full_name, m * 16 + l + k * 4, fvalue[m * 16 + l + k * 4], 0.0f);
1610                     }
1611                 }
1612             }
1613         }
1614
1615         for (l = res_desc->Elements * 16; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1616         {
1617             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixTransposeArray fvalue[%u] failed, got %f, expected %f\n",
1618                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1619         }
1620     }
1621     else
1622     {
1623         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTransposeArray failed, got %#x, expected %#x\n",
1624                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1625
1626         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1627         {
1628             ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixTransposeArray fvalue[%u] failed, got %f, expected %f\n",
1629                     i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1630         }
1631     }
1632 }
1633
1634 static void test_effect_parameter_value_GetMatrixTransposePointerArray(const struct test_effect_parameter_value_result *res,
1635         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1636 {
1637     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1638     LPCSTR res_full_name = res->full_name;
1639     HRESULT hr;
1640     DWORD cmp = 0xabababab;
1641     FLOAT fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1642     D3DXMATRIX *matrix_pointer_array[sizeof(fvalue)/sizeof(D3DXMATRIX)];
1643     UINT l, k, m, element;
1644
1645     for (element = 0; element <= res_desc->Elements + 1; ++element)
1646     {
1647         memset(fvalue, 0xab, sizeof(fvalue));
1648         for (l = 0; l < element; ++l)
1649         {
1650             matrix_pointer_array[l] = (D3DXMATRIX *)&fvalue[l * sizeof(**matrix_pointer_array) / sizeof(FLOAT)];
1651         }
1652         hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, parameter, matrix_pointer_array, element);
1653         if (!element)
1654         {
1655             ok(hr == D3D_OK, "%u - %s: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1656
1657             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1658             {
1659                 ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixTransposePointerArray fvalue[%u] failed, got %f, expected %f\n",
1660                         i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1661             }
1662         }
1663         else if (element <= res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1664         {
1665             ok(hr == D3D_OK, "%u - %s: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1666
1667             for (m = 0; m < element; ++m)
1668             {
1669                 for (k = 0; k < 4; ++k)
1670                 {
1671                     for (l = 0; l < 4; ++l)
1672                     {
1673                         if (k < res_desc->Columns && l < res_desc->Rows)
1674                         {
1675                             ok(compare_float(fvalue[m * 16 + l + k * 4], get_float(res_desc->Type,
1676                                     &res_value[m * res_desc->Columns * res_desc->Rows + l * res_desc->Columns + k]), 512),
1677                                     "%u - %s: GetMatrixTransposePointerArray fvalue[%u] failed, got %f, expected %f\n",
1678                                     i, res_full_name, m * 16 + l + k * 4, fvalue[m * 16 + l + k * 4],
1679                                     get_float(res_desc->Type, &res_value[m * res_desc->Columns * res_desc->Rows
1680                                     + l * res_desc->Columns + k]));
1681                         }
1682                         else
1683                         {
1684                             ok(fvalue[m * 16 + l + k * 4] == 0.0f, "%u - %s: GetMatrixTransposePointerArray fvalue[%u] failed, got %f, expected %f\n",
1685                                     i, res_full_name, m * 16 + l + k * 4, fvalue[m * 16 + l + k * 4], 0.0f);
1686                         }
1687                     }
1688                 }
1689             }
1690
1691             for (l = element * 16; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1692             {
1693                 ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixTransposePointerArray fvalue[%u] failed, got %f, expected %f\n",
1694                         i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1695             }
1696         }
1697         else
1698         {
1699             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
1700                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1701
1702             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1703             {
1704                 ok(fvalue[l] == *(FLOAT *)&cmp, "%u - %s: GetMatrixTransposePointerArray fvalue[%u] failed, got %f, expected %f\n",
1705                         i, res_full_name, l, fvalue[l], *(FLOAT *)&cmp);
1706             }
1707         }
1708     }
1709 }
1710
1711 static void test_effect_parameter_value_GetTestGroup(const struct test_effect_parameter_value_result *res,
1712         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1713 {
1714     test_effect_parameter_value_GetValue(res, effect, res_value, parameter, i);
1715     test_effect_parameter_value_GetBool(res, effect, res_value, parameter, i);
1716     test_effect_parameter_value_GetBoolArray(res, effect, res_value, parameter, i);
1717     test_effect_parameter_value_GetInt(res, effect, res_value, parameter, i);
1718     test_effect_parameter_value_GetIntArray(res, effect, res_value, parameter, i);
1719     test_effect_parameter_value_GetFloat(res, effect, res_value, parameter, i);
1720     test_effect_parameter_value_GetFloatArray(res, effect, res_value, parameter, i);
1721     test_effect_parameter_value_GetVector(res, effect, res_value, parameter, i);
1722     test_effect_parameter_value_GetVectorArray(res, effect, res_value, parameter, i);
1723     test_effect_parameter_value_GetMatrix(res, effect, res_value, parameter, i);
1724     test_effect_parameter_value_GetMatrixArray(res, effect, res_value, parameter, i);
1725     test_effect_parameter_value_GetMatrixPointerArray(res, effect, res_value, parameter, i);
1726     test_effect_parameter_value_GetMatrixTranspose(res, effect, res_value, parameter, i);
1727     test_effect_parameter_value_GetMatrixTransposeArray(res, effect, res_value, parameter, i);
1728     test_effect_parameter_value_GetMatrixTransposePointerArray(res, effect, res_value, parameter, i);
1729 }
1730
1731 static void test_effect_parameter_value_ResetValue(const struct test_effect_parameter_value_result *res,
1732         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1733 {
1734     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1735     LPCSTR res_full_name = res->full_name;
1736     HRESULT hr;
1737
1738     if (res_desc->Class == D3DXPC_SCALAR
1739             || res_desc->Class == D3DXPC_VECTOR
1740             || res_desc->Class == D3DXPC_MATRIX_ROWS)
1741     {
1742         hr = effect->lpVtbl->SetValue(effect, parameter, res_value, res_desc->Bytes);
1743         ok(hr == D3D_OK, "%u - %s: SetValue failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1744     }
1745     else
1746     {
1747         /* nothing to do */
1748         switch (res_desc->Type)
1749         {
1750             case D3DXPT_PIXELSHADER:
1751             case D3DXPT_VERTEXSHADER:
1752             case D3DXPT_TEXTURE2D:
1753             case D3DXPT_STRING:
1754                 break;
1755
1756             default:
1757                 ok(0, "Type is %u, this should not happen!\n", res_desc->Type);
1758                 break;
1759         }
1760     }
1761 }
1762
1763 static void test_effect_parameter_value(IDirect3DDevice9 *device)
1764 {
1765     UINT i;
1766     UINT effect_count = sizeof(test_effect_parameter_value_data) / sizeof(*test_effect_parameter_value_data);
1767
1768     for (i = 0; i < effect_count; ++i)
1769     {
1770         const struct test_effect_parameter_value_result *res = test_effect_parameter_value_data[i].res;
1771         UINT res_count = test_effect_parameter_value_data[i].res_count;
1772         const DWORD *blob = test_effect_parameter_value_data[i].blob;
1773         UINT blob_size = test_effect_parameter_value_data[i].blob_size;
1774         HRESULT hr;
1775         ID3DXEffect *effect;
1776         D3DXEFFECT_DESC edesc;
1777         ULONG count;
1778         UINT k;
1779
1780         hr = D3DXCreateEffect(device, blob, blob_size, NULL, NULL, 0, NULL, &effect, NULL);
1781         ok(hr == D3D_OK, "%u: D3DXCreateEffect failed, got %#x, expected %#x\n", i, hr, D3D_OK);
1782
1783         hr = effect->lpVtbl->GetDesc(effect, &edesc);
1784         ok(hr == D3D_OK, "%u: GetDesc failed, got %#x, expected %#x\n", i, hr, D3D_OK);
1785         ok(edesc.Parameters == res_count, "%u: Parameters failed, got %u, expected %u\n",
1786                 i, edesc.Parameters, res_count);
1787
1788         for (k = 0; k < res_count; ++k)
1789         {
1790             const D3DXPARAMETER_DESC *res_desc = &res[k].desc;
1791             LPCSTR res_full_name = res[k].full_name;
1792             UINT res_value_offset = res[k].value_offset;
1793             D3DXHANDLE parameter;
1794             D3DXPARAMETER_DESC pdesc;
1795             BOOL bvalue;
1796             INT ivalue;
1797             FLOAT fvalue;
1798             DWORD input_value[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1799             DWORD expected_value[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1800             UINT l, n, m, element;
1801             const D3DXMATRIX *matrix_pointer_array[sizeof(input_value)/sizeof(D3DXMATRIX)];
1802
1803             parameter = effect->lpVtbl->GetParameterByName(effect, NULL, res_full_name);
1804             ok(parameter != NULL, "%u - %s: GetParameterByName failed\n", i, res_full_name);
1805
1806             hr = effect->lpVtbl->GetParameterDesc(effect, parameter, &pdesc);
1807             ok(hr == D3D_OK, "%u - %s: GetParameterDesc failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1808
1809             ok(res_desc->Name ? !strcmp(pdesc.Name, res_desc->Name) : !pdesc.Name,
1810                     "%u - %s: GetParameterDesc Name failed, got \"%s\", expected \"%s\"\n",
1811                     i, res_full_name, pdesc.Name, res_desc->Name);
1812             ok(res_desc->Semantic ? !strcmp(pdesc.Semantic, res_desc->Semantic) : !pdesc.Semantic,
1813                     "%u - %s: GetParameterDesc Semantic failed, got \"%s\", expected \"%s\"\n",
1814                     i, res_full_name, pdesc.Semantic, res_desc->Semantic);
1815             ok(res_desc->Class == pdesc.Class, "%u - %s: GetParameterDesc Class failed, got %#x, expected %#x\n",
1816                     i, res_full_name, pdesc.Class, res_desc->Class);
1817             ok(res_desc->Type == pdesc.Type, "%u - %s: GetParameterDesc Type failed, got %#x, expected %#x\n",
1818                     i, res_full_name, pdesc.Type, res_desc->Type);
1819             ok(res_desc->Rows == pdesc.Rows, "%u - %s: GetParameterDesc Rows failed, got %u, expected %u\n",
1820                     i, res_full_name, pdesc.Rows, res_desc->Rows);
1821             ok(res_desc->Columns == pdesc.Columns, "%u - %s: GetParameterDesc Columns failed, got %u, expected %u\n",
1822                     i, res_full_name, pdesc.Columns, res_desc->Columns);
1823             ok(res_desc->Elements == pdesc.Elements, "%u - %s: GetParameterDesc Elements failed, got %u, expected %u\n",
1824                     i, res_full_name, pdesc.Elements, res_desc->Elements);
1825             ok(res_desc->Annotations == pdesc.Annotations, "%u - %s: GetParameterDesc Annotations failed, got %u, expected %u\n",
1826                     i, res_full_name, pdesc.Annotations, res_desc->Annotations);
1827             ok(res_desc->StructMembers == pdesc.StructMembers, "%u - %s: GetParameterDesc StructMembers failed, got %u, expected %u\n",
1828                     i, res_full_name, pdesc.StructMembers, res_desc->StructMembers);
1829             ok(res_desc->Flags == pdesc.Flags, "%u - %s: GetParameterDesc Flags failed, got %u, expected %u\n",
1830                     i, res_full_name, pdesc.Flags, res_desc->Flags);
1831             ok(res_desc->Bytes == pdesc.Bytes, "%u - %s: GetParameterDesc Bytes, got %u, expected %u\n",
1832                     i, res_full_name, pdesc.Bytes, res_desc->Bytes);
1833
1834             /* check size */
1835             ok(EFFECT_PARAMETER_VALUE_ARRAY_SIZE >= res_desc->Bytes / 4 +
1836                     (res_desc->Elements ? res_desc->Bytes / 4 / res_desc->Elements : 0),
1837                     "%u - %s: Warning: Array size to small\n", i, res_full_name);
1838
1839             test_effect_parameter_value_GetTestGroup(&res[k], effect, &blob[res_value_offset], parameter, i);
1840             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
1841             test_effect_parameter_value_GetTestGroup(&res[k], effect, &blob[res_value_offset], parameter, i);
1842
1843             /*
1844              * check invalid calls
1845              * These will crash:
1846              * effect->lpVtbl->SetBoolArray(effect, parameter, NULL, res_desc->Bytes / sizeof(BOOL));
1847              * effect->lpVtbl->SetIntArray(effect, parameter, NULL, res_desc->Bytes / sizeof(INT));
1848              * effect->lpVtbl->SetFloatArray(effect, parameter, NULL, res_desc->Bytes / sizeof(FLOAT));
1849              * effect->lpVtbl->SetVector(effect, parameter, NULL);
1850              * effect->lpVtbl->SetVectorArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1851              * effect->lpVtbl->SetMatrix(effect, parameter, NULL);
1852              * effect->lpVtbl->GetMatrix(effect, parameter, NULL);
1853              * effect->lpVtbl->SetMatrixArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1854              * effect->lpVtbl->SetMatrixPointerArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1855              * effect->lpVtbl->SetMatrixTranspose(effect, parameter, NULL);
1856              * effect->lpVtbl->SetMatrixTransposeArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1857              * effect->lpVtbl->SetMatrixTransposePointerArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1858              * effect->lpVtbl->GetValue(effect, parameter, NULL, res_desc->Bytes);
1859              * effect->lpVtbl->SetValue(effect, parameter, NULL, res_desc->Bytes);
1860              */
1861             hr = effect->lpVtbl->SetBool(effect, NULL, bvalue);
1862             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetBool failed, got %#x, expected %#x\n",
1863                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1864
1865             hr = effect->lpVtbl->GetBool(effect, NULL, &bvalue);
1866             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetBool failed, got %#x, expected %#x\n",
1867                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1868
1869             hr = effect->lpVtbl->GetBool(effect, parameter, NULL);
1870             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetBool failed, got %#x, expected %#x\n",
1871                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1872
1873             hr = effect->lpVtbl->SetBoolArray(effect, NULL, (BOOL *)input_value, res_desc->Bytes / sizeof(BOOL));
1874             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetBoolArray failed, got %#x, expected %#x\n",
1875                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1876
1877             hr = effect->lpVtbl->GetBoolArray(effect, NULL, (BOOL *)input_value, res_desc->Bytes / sizeof(BOOL));
1878             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetBoolArray failed, got %#x, expected %#x\n",
1879                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1880
1881             hr = effect->lpVtbl->GetBoolArray(effect, parameter, NULL, res_desc->Bytes / sizeof(BOOL));
1882             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetBoolArray failed, got %#x, expected %#x\n",
1883                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1884
1885             hr = effect->lpVtbl->SetInt(effect, NULL, ivalue);
1886             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetInt failed, got %#x, expected %#x\n",
1887                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1888
1889             hr = effect->lpVtbl->GetInt(effect, NULL, &ivalue);
1890             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetInt failed, got %#x, expected %#x\n",
1891                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1892
1893             hr = effect->lpVtbl->GetInt(effect, parameter, NULL);
1894             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetInt failed, got %#x, expected %#x\n",
1895                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1896
1897             hr = effect->lpVtbl->SetIntArray(effect, NULL, (INT *)input_value, res_desc->Bytes / sizeof(INT));
1898             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetIntArray failed, got %#x, expected %#x\n",
1899                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1900
1901             hr = effect->lpVtbl->GetIntArray(effect, NULL, (INT *)input_value, res_desc->Bytes / sizeof(INT));
1902             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetIntArray failed, got %#x, expected %#x\n",
1903                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1904
1905             hr = effect->lpVtbl->GetIntArray(effect, parameter, NULL, res_desc->Bytes / sizeof(INT));
1906             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetIntArray failed, got %#x, expected %#x\n",
1907                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1908
1909             hr = effect->lpVtbl->SetFloat(effect, NULL, fvalue);
1910             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetFloat failed, got %#x, expected %#x\n",
1911                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1912
1913             hr = effect->lpVtbl->GetFloat(effect, NULL, &fvalue);
1914             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloat failed, got %#x, expected %#x\n",
1915                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1916
1917             hr = effect->lpVtbl->GetFloat(effect, parameter, NULL);
1918             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloat failed, got %#x, expected %#x\n",
1919                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1920
1921             hr = effect->lpVtbl->SetFloatArray(effect, NULL, (FLOAT *)input_value, res_desc->Bytes / sizeof(FLOAT));
1922             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetFloatArray failed, got %#x, expected %#x\n",
1923                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1924
1925             hr = effect->lpVtbl->GetFloatArray(effect, NULL, (FLOAT *)input_value, res_desc->Bytes / sizeof(FLOAT));
1926             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloatArray failed, got %#x, expected %#x\n",
1927                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1928
1929             hr = effect->lpVtbl->GetFloatArray(effect, parameter, NULL, res_desc->Bytes / sizeof(FLOAT));
1930             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloatArray failed, got %#x, expected %#x\n",
1931                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1932
1933             hr = effect->lpVtbl->SetVector(effect, NULL, (D3DXVECTOR4 *)input_value);
1934             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetVector failed, got %#x, expected %#x\n",
1935                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1936
1937             hr = effect->lpVtbl->GetVector(effect, NULL, (D3DXVECTOR4 *)input_value);
1938             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetVector failed, got %#x, expected %#x\n",
1939                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1940
1941             hr = effect->lpVtbl->GetVector(effect, parameter, NULL);
1942             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetVector failed, got %#x, expected %#x\n",
1943                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1944
1945             hr = effect->lpVtbl->SetVectorArray(effect, NULL, (D3DXVECTOR4 *)input_value, res_desc->Elements ? res_desc->Elements : 1);
1946             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetVectorArray failed, got %#x, expected %#x\n",
1947                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1948
1949             hr = effect->lpVtbl->GetVectorArray(effect, NULL, (D3DXVECTOR4 *)input_value, res_desc->Elements ? res_desc->Elements : 1);
1950             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetVectorArray failed, got %#x, expected %#x\n",
1951                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1952
1953             hr = effect->lpVtbl->GetVectorArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1954             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetVectorArray failed, got %#x, expected %#x\n",
1955                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1956
1957             hr = effect->lpVtbl->SetMatrix(effect, NULL, (D3DXMATRIX *)input_value);
1958             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrix failed, got %#x, expected %#x\n",
1959                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1960
1961             hr = effect->lpVtbl->GetMatrix(effect, NULL, (D3DXMATRIX *)input_value);
1962             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrix failed, got %#x, expected %#x\n",
1963                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1964
1965             hr = effect->lpVtbl->SetMatrixArray(effect, NULL, (D3DXMATRIX *)input_value, res_desc->Elements ? res_desc->Elements : 1);
1966             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixArray failed, got %#x, expected %#x\n",
1967                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1968
1969             hr = effect->lpVtbl->GetMatrixArray(effect, NULL, (D3DXMATRIX *)input_value, res_desc->Elements ? res_desc->Elements : 1);
1970             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixArray failed, got %#x, expected %#x\n",
1971                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1972
1973             hr = effect->lpVtbl->GetMatrixArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1974             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixArray failed, got %#x, expected %#x\n",
1975                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1976
1977             hr = effect->lpVtbl->SetMatrixPointerArray(effect, NULL, matrix_pointer_array, res_desc->Elements ? res_desc->Elements : 1);
1978             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixPointerArray failed, got %#x, expected %#x\n",
1979                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1980
1981             hr = effect->lpVtbl->SetMatrixPointerArray(effect, NULL, matrix_pointer_array, 0);
1982             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixPointerArray failed, got %#x, expected %#x\n",
1983                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1984
1985             hr = effect->lpVtbl->GetMatrixPointerArray(effect, NULL, NULL, 0);
1986             ok(hr == D3D_OK, "%u - %s: GetMatrixPointerArray failed, got %#x, expected %#x\n",
1987                     i, res_full_name, hr, D3D_OK);
1988
1989             hr = effect->lpVtbl->GetMatrixPointerArray(effect, NULL, NULL, res_desc->Elements ? res_desc->Elements : 1);
1990             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixPointerArray failed, got %#x, expected %#x\n",
1991                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1992
1993             hr = effect->lpVtbl->GetMatrixPointerArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1994             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixPointerArray failed, got %#x, expected %#x\n",
1995                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1996
1997             hr = effect->lpVtbl->SetMatrixTranspose(effect, NULL, (D3DXMATRIX *)input_value);
1998             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTranspose failed, got %#x, expected %#x\n",
1999                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2000
2001             hr = effect->lpVtbl->GetMatrixTranspose(effect, NULL, (D3DXMATRIX *)input_value);
2002             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTranspose failed, got %#x, expected %#x\n",
2003                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2004
2005             hr = effect->lpVtbl->GetMatrixTranspose(effect, parameter, NULL);
2006             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTranspose failed, got %#x, expected %#x\n",
2007                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2008
2009             hr = effect->lpVtbl->SetMatrixTransposeArray(effect, NULL, (D3DXMATRIX *)input_value, res_desc->Elements ? res_desc->Elements : 1);
2010             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTransposeArray failed, got %#x, expected %#x\n",
2011                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2012
2013             hr = effect->lpVtbl->GetMatrixTransposeArray(effect, NULL, (D3DXMATRIX *)input_value, res_desc->Elements ? res_desc->Elements : 1);
2014             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTransposeArray failed, got %#x, expected %#x\n",
2015                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2016
2017             hr = effect->lpVtbl->GetMatrixTransposeArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
2018             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTransposeArray failed, got %#x, expected %#x\n",
2019                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2020
2021             hr = effect->lpVtbl->SetMatrixTransposePointerArray(effect, NULL, matrix_pointer_array, res_desc->Elements ? res_desc->Elements : 1);
2022             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
2023                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2024
2025             hr = effect->lpVtbl->SetMatrixTransposePointerArray(effect, NULL, matrix_pointer_array, 0);
2026             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
2027                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2028
2029             hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, NULL, NULL, 0);
2030             ok(hr == D3D_OK, "%u - %s: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
2031                     i, res_full_name, hr, D3D_OK);
2032
2033             hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, NULL, NULL, res_desc->Elements ? res_desc->Elements : 1);
2034             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
2035                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2036
2037             hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
2038             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
2039                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2040
2041             hr = effect->lpVtbl->SetValue(effect, NULL, input_value, res_desc->Bytes);
2042             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetValue failed, got %#x, expected %#x\n",
2043                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2044
2045             hr = effect->lpVtbl->SetValue(effect, parameter, input_value, res_desc->Bytes - 1);
2046             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetValue failed, got %#x, expected %#x\n",
2047                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2048
2049             hr = effect->lpVtbl->GetValue(effect, NULL, input_value, res_desc->Bytes);
2050             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetValue failed, got %#x, expected %#x\n",
2051                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2052
2053             hr = effect->lpVtbl->GetValue(effect, parameter, input_value, res_desc->Bytes - 1);
2054             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetValue failed, got %#x, expected %#x\n",
2055                     i, res_full_name, hr, D3DERR_INVALIDCALL);
2056
2057             test_effect_parameter_value_GetTestGroup(&res[k], effect, &blob[res_value_offset], parameter, i);
2058
2059             /* SetBool */
2060             bvalue = 5;
2061             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2062             hr = effect->lpVtbl->SetBool(effect, parameter, bvalue);
2063             if (!res_desc->Elements && res_desc->Rows == 1 && res_desc->Columns == 1)
2064             {
2065                 bvalue = bvalue ? TRUE : FALSE;
2066                 set_number(expected_value, res_desc->Type, &bvalue, D3DXPT_BOOL);
2067                 ok(hr == D3D_OK, "%u - %s: SetBool failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2068             }
2069             else
2070             {
2071                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetBool failed, got %#x, expected %#x\n",
2072                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2073             }
2074             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2075             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2076
2077             /* SetBoolArray */
2078             *input_value = 1;
2079             for (l = 1; l < res_desc->Bytes / sizeof(*input_value); ++l)
2080             {
2081                 *(input_value + l) = *(input_value + l - 1) + 1;
2082             }
2083             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2084             hr = effect->lpVtbl->SetBoolArray(effect, parameter, (BOOL *)input_value, res_desc->Bytes / sizeof(*input_value));
2085             if (res_desc->Class == D3DXPC_SCALAR
2086                     || res_desc->Class == D3DXPC_VECTOR
2087                     || res_desc->Class == D3DXPC_MATRIX_ROWS)
2088             {
2089                 for (l = 0; l < res_desc->Bytes / sizeof(*input_value); ++l)
2090                 {
2091                     set_number(expected_value + l, res_desc->Type, input_value + l, D3DXPT_BOOL);
2092                 }
2093                 ok(hr == D3D_OK, "%u - %s: SetBoolArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2094             }
2095             else
2096             {
2097                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetBoolArray failed, got %#x, expected %#x\n",
2098                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2099             }
2100             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2101             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2102
2103             /* SetInt */
2104             ivalue = 0x1fbf02ff;
2105             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2106             hr = effect->lpVtbl->SetInt(effect, parameter, ivalue);
2107             if (!res_desc->Elements && res_desc->Rows == 1 && res_desc->Columns == 1)
2108             {
2109                 set_number(expected_value, res_desc->Type, &ivalue, D3DXPT_INT);
2110                 ok(hr == D3D_OK, "%u - %s: SetInt failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2111             }
2112             else if(!res_desc->Elements && res_desc->Type == D3DXPT_FLOAT &&
2113                     ((res_desc->Class == D3DXPC_VECTOR && res_desc->Columns != 2) ||
2114                     (res_desc->Class == D3DXPC_MATRIX_ROWS && res_desc->Rows != 2 && res_desc->Columns == 1)))
2115             {
2116                 FLOAT tmp = ((ivalue & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE;
2117                 set_number(expected_value, res_desc->Type, &tmp, D3DXPT_FLOAT);
2118                 tmp = ((ivalue & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE;
2119                 set_number(expected_value + 1, res_desc->Type, &tmp, D3DXPT_FLOAT);
2120                 tmp = (ivalue & 0xff) * INT_FLOAT_MULTI_INVERSE;
2121                 set_number(expected_value + 2, res_desc->Type, &tmp, D3DXPT_FLOAT);
2122                 tmp = ((ivalue & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
2123                 set_number(expected_value + 3, res_desc->Type, &tmp, D3DXPT_FLOAT);
2124
2125                 ok(hr == D3D_OK, "%u - %s: SetInt failed, got %#x, expected %#x\n",
2126                         i, res_full_name, hr, D3D_OK);
2127             }
2128             else
2129             {
2130                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetInt failed, got %#x, expected %#x\n",
2131                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2132             }
2133             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2134             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2135
2136             /* SetIntArray */
2137             *input_value = 123456;
2138             for (l = 0; l < res_desc->Bytes / sizeof(*input_value); ++l)
2139             {
2140                 *(input_value + l) = *(input_value + l - 1) + 23;
2141             }
2142             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2143             hr = effect->lpVtbl->SetIntArray(effect, parameter, (INT *)input_value, res_desc->Bytes / sizeof(*input_value));
2144             if (res_desc->Class == D3DXPC_SCALAR
2145                     || res_desc->Class == D3DXPC_VECTOR
2146                     || res_desc->Class == D3DXPC_MATRIX_ROWS)
2147             {
2148                 for (l = 0; l < res_desc->Bytes / sizeof(*input_value); ++l)
2149                 {
2150                     set_number(expected_value + l, res_desc->Type, input_value + l, D3DXPT_INT);
2151                 }
2152                 ok(hr == D3D_OK, "%u - %s: SetIntArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2153             }
2154             else
2155             {
2156                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetIntArray failed, got %#x, expected %#x\n",
2157                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2158             }
2159             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2160             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2161
2162             /* SetFloat */
2163             fvalue = 1.33;
2164             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2165             hr = effect->lpVtbl->SetFloat(effect, parameter, fvalue);
2166             if (!res_desc->Elements && res_desc->Rows == 1 && res_desc->Columns == 1)
2167             {
2168                 set_number(expected_value, res_desc->Type, &fvalue, D3DXPT_FLOAT);
2169                 ok(hr == D3D_OK, "%u - %s: SetFloat failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2170             }
2171             else
2172             {
2173                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetFloat failed, got %#x, expected %#x\n",
2174                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2175             }
2176             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2177             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2178
2179             /* SetFloatArray */
2180             fvalue = 1.33;
2181             for (l = 0; l < res_desc->Bytes / sizeof(fvalue); ++l)
2182             {
2183                 *(input_value + l) = *(DWORD *)&fvalue;
2184                 fvalue += 1.12;
2185             }
2186             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2187             hr = effect->lpVtbl->SetFloatArray(effect, parameter, (FLOAT *)input_value, res_desc->Bytes / sizeof(*input_value));
2188             if (res_desc->Class == D3DXPC_SCALAR
2189                     || res_desc->Class == D3DXPC_VECTOR
2190                     || res_desc->Class == D3DXPC_MATRIX_ROWS)
2191             {
2192                 for (l = 0; l < res_desc->Bytes / sizeof(*input_value); ++l)
2193                 {
2194                     set_number(expected_value + l, res_desc->Type, input_value + l, D3DXPT_FLOAT);
2195                 }
2196                 ok(hr == D3D_OK, "%u - %s: SetFloatArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2197             }
2198             else
2199             {
2200                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetFloatArray failed, got %#x, expected %#x\n",
2201                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2202             }
2203             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2204             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2205
2206             /* SetVector */
2207             fvalue = -1.33;
2208             for (l = 0; l < 4; ++l)
2209             {
2210                 *(input_value + l) = *(DWORD *)&fvalue;
2211                 fvalue += 1.12;
2212             }
2213             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2214             hr = effect->lpVtbl->SetVector(effect, parameter, (D3DXVECTOR4 *)input_value);
2215             if (!res_desc->Elements &&
2216                     (res_desc->Class == D3DXPC_SCALAR
2217                     || res_desc->Class == D3DXPC_VECTOR))
2218             {
2219                 /* only values between 0 and INT_FLOAT_MULTI are valid */
2220                 if (res_desc->Type == D3DXPT_INT && res_desc->Bytes == 4)
2221                 {
2222                     *expected_value = (DWORD)(max(min(*(FLOAT *)(input_value + 2), 1.0f), 0.0f) * INT_FLOAT_MULTI);
2223                     *expected_value += ((DWORD)(max(min(*(FLOAT *)(input_value + 1), 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 8;
2224                     *expected_value += ((DWORD)(max(min(*(FLOAT *)input_value, 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 16;
2225                     *expected_value += ((DWORD)(max(min(*(FLOAT *)(input_value + 3), 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 24;
2226                 }
2227                 else
2228                 {
2229                     for (l = 0; l < 4; ++l)
2230                     {
2231                         set_number(expected_value + l, res_desc->Type, input_value + l, D3DXPT_FLOAT);
2232                     }
2233                 }
2234                 ok(hr == D3D_OK, "%u - %s: SetVector failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2235             }
2236             else
2237             {
2238                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetVector failed, got %#x, expected %#x\n",
2239                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2240             }
2241             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2242             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2243
2244             /* SetVectorArray */
2245             for (element = 0; element < res_desc->Elements + 1; ++element)
2246             {
2247                 fvalue = 1.33;
2248                 for (l = 0; l < element * 4; ++l)
2249                 {
2250                     *(input_value + l) = *(DWORD *)&fvalue;
2251                     fvalue += 1.12;
2252                 }
2253                 memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2254                 hr = effect->lpVtbl->SetVectorArray(effect, parameter, (D3DXVECTOR4 *)input_value, element);
2255                 if (res_desc->Elements && res_desc->Class == D3DXPC_VECTOR && element <= res_desc->Elements)
2256                 {
2257                     for (m = 0; m < element; ++m)
2258                     {
2259                         for (l = 0; l < res_desc->Columns; ++l)
2260                         {
2261                             set_number(expected_value + m * res_desc->Columns + l, res_desc->Type, input_value + m * 4 + l, D3DXPT_FLOAT);
2262                         }
2263                     }
2264                     ok(hr == D3D_OK, "%u - %s: SetVectorArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2265                 }
2266                 else
2267                 {
2268                     ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetVectorArray failed, got %#x, expected %#x\n",
2269                             i, res_full_name, hr, D3DERR_INVALIDCALL);
2270                 }
2271                 test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2272                 test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2273             }
2274
2275             /* SetMatrix */
2276             fvalue = 1.33;
2277             for (l = 0; l < 16; ++l)
2278             {
2279                 *(input_value + l) = *(DWORD *)&fvalue;
2280                 fvalue += 1.12;
2281             }
2282             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2283             hr = effect->lpVtbl->SetMatrix(effect, parameter, (D3DXMATRIX *)input_value);
2284             if (!res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
2285             {
2286                 for (l = 0; l < 4; ++l)
2287                 {
2288                     for (m = 0; m < 4; ++m)
2289                     {
2290                         if (m < res_desc->Rows && l < res_desc->Columns)
2291                             set_number(expected_value + l + m * res_desc->Columns, res_desc->Type,
2292                                     input_value + l + m * 4, D3DXPT_FLOAT);
2293                     }
2294
2295                 }
2296                 ok(hr == D3D_OK, "%u - %s: SetMatrix failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2297             }
2298             else
2299             {
2300                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrix failed, got %#x, expected %#x\n",
2301                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2302             }
2303             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2304             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2305
2306             /* SetMatrixArray */
2307             for (element = 0; element < res_desc->Elements + 1; ++element)
2308             {
2309                 fvalue = 1.33;
2310                 for (l = 0; l < element * 16; ++l)
2311                 {
2312                     *(input_value + l) = *(DWORD *)&fvalue;
2313                     fvalue += 1.12;
2314                 }
2315                 memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2316                 hr = effect->lpVtbl->SetMatrixArray(effect, parameter, (D3DXMATRIX *)input_value, element);
2317                 if (res_desc->Class == D3DXPC_MATRIX_ROWS && element <= res_desc->Elements)
2318                 {
2319                     for (n = 0; n < element; ++n)
2320                     {
2321                         for (l = 0; l < 4; ++l)
2322                         {
2323                             for (m = 0; m < 4; ++m)
2324                             {
2325                                 if (m < res_desc->Rows && l < res_desc->Columns)
2326                                     set_number(expected_value + l + m * res_desc->Columns + n * res_desc->Columns * res_desc->Rows,
2327                                             res_desc->Type, input_value + l + m * 4 + n * 16, D3DXPT_FLOAT);
2328                             }
2329
2330                         }
2331                     }
2332                     ok(hr == D3D_OK, "%u - %s: SetMatrixArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2333                 }
2334                 else
2335                 {
2336                     ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixArray failed, got %#x, expected %#x\n",
2337                             i, res_full_name, hr, D3DERR_INVALIDCALL);
2338                 }
2339                 test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2340                 test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2341             }
2342
2343             /* SetMatrixPointerArray */
2344             for (element = 0; element < res_desc->Elements + 1; ++element)
2345             {
2346                 fvalue = 1.33;
2347                 for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
2348                 {
2349                     *(input_value + l) = *(DWORD *)&fvalue;
2350                     fvalue += 1.12;
2351                 }
2352                 memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2353                 for (l = 0; l < element; ++l)
2354                 {
2355                     matrix_pointer_array[l] = (D3DXMATRIX *)&input_value[l * sizeof(**matrix_pointer_array) / sizeof(FLOAT)];
2356                 }
2357                 hr = effect->lpVtbl->SetMatrixPointerArray(effect, parameter, matrix_pointer_array, element);
2358                 if (res_desc->Class == D3DXPC_MATRIX_ROWS && res_desc->Elements >= element)
2359                 {
2360                     for (n = 0; n < element; ++n)
2361                     {
2362                         for (l = 0; l < 4; ++l)
2363                         {
2364                             for (m = 0; m < 4; ++m)
2365                             {
2366                                 if (m < res_desc->Rows && l < res_desc->Columns)
2367                                     set_number(expected_value + l + m * res_desc->Columns + n * res_desc->Columns * res_desc->Rows,
2368                                             res_desc->Type, input_value + l + m * 4 + n * 16, D3DXPT_FLOAT);
2369                             }
2370
2371                         }
2372                     }
2373                     ok(hr == D3D_OK, "%u - %s: SetMatrixPointerArray failed, got %#x, expected %#x\n",
2374                             i, res_full_name, hr, D3D_OK);
2375                 }
2376                 else
2377                 {
2378                     ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixPointerArray failed, got %#x, expected %#x\n",
2379                             i, res_full_name, hr, D3DERR_INVALIDCALL);
2380                 }
2381                 test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2382                 test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2383             }
2384
2385             /* SetMatrixTranspose */
2386             fvalue = 1.33;
2387             for (l = 0; l < 16; ++l)
2388             {
2389                 *(input_value + l) = *(DWORD *)&fvalue;
2390                 fvalue += 1.12;
2391             }
2392             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2393             hr = effect->lpVtbl->SetMatrixTranspose(effect, parameter, (D3DXMATRIX *)input_value);
2394             if (!res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
2395             {
2396                 for (l = 0; l < 4; ++l)
2397                 {
2398                     for (m = 0; m < 4; ++m)
2399                     {
2400                         if (m < res_desc->Rows && l < res_desc->Columns)
2401                             set_number(expected_value + l + m * res_desc->Columns, res_desc->Type,
2402                                     input_value + l * 4 + m, D3DXPT_FLOAT);
2403                     }
2404
2405                 }
2406                 ok(hr == D3D_OK, "%u - %s: SetMatrixTranspose failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2407             }
2408             else
2409             {
2410                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTranspose failed, got %#x, expected %#x\n",
2411                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2412             }
2413             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2414             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2415
2416             /* SetMatrixTransposeArray */
2417             for (element = 0; element < res_desc->Elements + 1; ++element)
2418             {
2419                 fvalue = 1.33;
2420                 for (l = 0; l < element * 16; ++l)
2421                 {
2422                     *(input_value + l) = *(DWORD *)&fvalue;
2423                     fvalue += 1.12;
2424                 }
2425                 memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2426                 hr = effect->lpVtbl->SetMatrixTransposeArray(effect, parameter, (D3DXMATRIX *)input_value, element);
2427                 if (res_desc->Class == D3DXPC_MATRIX_ROWS && element <= res_desc->Elements)
2428                 {
2429                     for (n = 0; n < element; ++n)
2430                     {
2431                         for (l = 0; l < 4; ++l)
2432                         {
2433                             for (m = 0; m < 4; ++m)
2434                             {
2435                                 if (m < res_desc->Rows && l < res_desc->Columns)
2436                                     set_number(expected_value + l + m * res_desc->Columns + n * res_desc->Columns * res_desc->Rows,
2437                                             res_desc->Type, input_value + l * 4 + m + n * 16, D3DXPT_FLOAT);
2438                             }
2439
2440                         }
2441                     }
2442                     ok(hr == D3D_OK, "%u - %s: SetMatrixTransposeArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2443                 }
2444                 else
2445                 {
2446                     ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTransposeArray failed, got %#x, expected %#x\n",
2447                             i, res_full_name, hr, D3DERR_INVALIDCALL);
2448                 }
2449                 test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2450                 test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2451             }
2452
2453             /* SetMatrixTransposePointerArray */
2454             for (element = 0; element < res_desc->Elements + 1; ++element)
2455             {
2456                 fvalue = 1.33;
2457                 for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
2458                 {
2459                     *(input_value + l) = *(DWORD *)&fvalue;
2460                     fvalue += 1.12;
2461                 }
2462                 memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2463                 for (l = 0; l < element; ++l)
2464                 {
2465                     matrix_pointer_array[l] = (D3DXMATRIX *)&input_value[l * sizeof(**matrix_pointer_array) / sizeof(FLOAT)];
2466                 }
2467                 hr = effect->lpVtbl->SetMatrixTransposePointerArray(effect, parameter, matrix_pointer_array, element);
2468                 if (res_desc->Class == D3DXPC_MATRIX_ROWS && res_desc->Elements >= element)
2469                 {
2470                     for (n = 0; n < element; ++n)
2471                     {
2472                         for (l = 0; l < 4; ++l)
2473                         {
2474                             for (m = 0; m < 4; ++m)
2475                             {
2476                                 if (m < res_desc->Rows && l < res_desc->Columns)
2477                                     set_number(expected_value + l + m * res_desc->Columns + n * res_desc->Columns * res_desc->Rows,
2478                                             res_desc->Type, input_value + l * 4 + m + n * 16, D3DXPT_FLOAT);
2479                             }
2480
2481                         }
2482                     }
2483                     ok(hr == D3D_OK, "%u - %s: SetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
2484                             i, res_full_name, hr, D3D_OK);
2485                 }
2486                 else
2487                 {
2488                     ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
2489                             i, res_full_name, hr, D3DERR_INVALIDCALL);
2490                 }
2491                 test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2492                 test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2493             }
2494         }
2495
2496         count = effect->lpVtbl->Release(effect);
2497         ok(!count, "Release failed %u\n", count);
2498     }
2499 }
2500
2501 START_TEST(effect)
2502 {
2503     HWND wnd;
2504     IDirect3D9 *d3d;
2505     IDirect3DDevice9 *device;
2506     D3DPRESENT_PARAMETERS d3dpp;
2507     HRESULT hr;
2508     ULONG count;
2509
2510     wnd = CreateWindow("static", "d3dx9_test", 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
2511     d3d = Direct3DCreate9(D3D_SDK_VERSION);
2512     if (!wnd) {
2513         skip("Couldn't create application window\n");
2514         return;
2515     }
2516     if (!d3d) {
2517         skip("Couldn't create IDirect3D9 object\n");
2518         DestroyWindow(wnd);
2519         return;
2520     }
2521
2522     ZeroMemory(&d3dpp, sizeof(d3dpp));
2523     d3dpp.Windowed = TRUE;
2524     d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
2525     hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, wnd, D3DCREATE_MIXED_VERTEXPROCESSING, &d3dpp, &device);
2526     if (FAILED(hr)) {
2527         skip("Failed to create IDirect3DDevice9 object %#x\n", hr);
2528         IDirect3D9_Release(d3d);
2529         DestroyWindow(wnd);
2530         return;
2531     }
2532
2533     test_create_effect_and_pool(device);
2534     test_create_effect_compiler();
2535     test_effect_parameter_value(device);
2536
2537     count = IDirect3DDevice9_Release(device);
2538     ok(count == 0, "The device was not properly freed: refcount %u\n", count);
2539
2540     count = IDirect3D9_Release(d3d);
2541     ok(count == 0, "Release failed %u\n", count);
2542
2543     DestroyWindow(wnd);
2544 }