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, err = 0;
 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             if (bavalue[l] != get_bool(&res_value[l])) ++err;
1005         }
1006
1007         for (l = res_desc->Bytes / sizeof(*bavalue); l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1008         {
1009             if (bavalue[l] != 0xabababab) ++err;
1010         }
1011     }
1012     else
1013     {
1014         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetBoolArray failed, got %#x, expected %#x\n",
1015                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1016
1017         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (bavalue[l] != 0xabababab) ++err;
1018     }
1019     ok(!err, "%u - %s: GetBoolArray failed with %u errors\n", i, res_full_name, err);
1020 }
1021
1022 static void test_effect_parameter_value_GetInt(const struct test_effect_parameter_value_result *res,
1023         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1024 {
1025     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1026     LPCSTR res_full_name = res->full_name;
1027     INT ivalue = 0xabababab;
1028     HRESULT hr;
1029
1030     hr = effect->lpVtbl->GetInt(effect, parameter, &ivalue);
1031     if (!res_desc->Elements && res_desc->Columns == 1 && res_desc->Rows == 1)
1032     {
1033         ok(hr == D3D_OK, "%u - %s: GetInt failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1034         ok(ivalue == get_int(res_desc->Type, res_value), "%u - %s: GetInt ivalue failed, got %i, expected %i\n",
1035                 i, res_full_name, ivalue, get_int(res_desc->Type, res_value));
1036     }
1037     else if(!res_desc->Elements && res_desc->Type == D3DXPT_FLOAT &&
1038             ((res_desc->Class == D3DXPC_VECTOR && res_desc->Columns != 2) ||
1039             (res_desc->Class == D3DXPC_MATRIX_ROWS && res_desc->Rows != 2 && res_desc->Columns == 1)))
1040     {
1041         INT tmp;
1042
1043         ok(hr == D3D_OK, "%u - %s: GetInt failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1044
1045         tmp = (INT)(min(max(0.0f, *((FLOAT *)res_value + 2)), 1.0f) * INT_FLOAT_MULTI);
1046         tmp += ((INT)(min(max(0.0f, *((FLOAT *)res_value + 1)), 1.0f) * INT_FLOAT_MULTI)) << 8;
1047         tmp += ((INT)(min(max(0.0f, *((FLOAT *)res_value + 0)), 1.0f) * INT_FLOAT_MULTI)) << 16;
1048         if (res_desc->Columns * res_desc->Rows > 3)
1049         {
1050             tmp += ((INT)(min(max(0.0f, *((FLOAT *)res_value + 3)), 1.0f) * INT_FLOAT_MULTI)) << 24;
1051         }
1052
1053         ok(ivalue == tmp, "%u - %s: GetInt ivalue failed, got %x, expected %x\n",
1054                 i, res_full_name, ivalue, tmp);
1055     }
1056     else
1057     {
1058         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetInt failed, got %#x, expected %#x\n",
1059                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1060         ok(ivalue == 0xabababab, "%u - %s: GetInt ivalue failed, got %i, expected %i\n",
1061                 i, res_full_name, ivalue, 0xabababab);
1062     }
1063 }
1064
1065 static void test_effect_parameter_value_GetIntArray(const struct test_effect_parameter_value_result *res,
1066         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1067 {
1068     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1069     LPCSTR res_full_name = res->full_name;
1070     INT iavalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1071     HRESULT hr;
1072     UINT l, err = 0;
1073
1074     memset(iavalue, 0xab, sizeof(iavalue));
1075     hr = effect->lpVtbl->GetIntArray(effect, parameter, iavalue, res_desc->Bytes / sizeof(*iavalue));
1076     if (res_desc->Class == D3DXPC_SCALAR
1077             || res_desc->Class == D3DXPC_VECTOR
1078             || res_desc->Class == D3DXPC_MATRIX_ROWS)
1079     {
1080         ok(hr == D3D_OK, "%u - %s: GetIntArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1081
1082         for (l = 0; l < res_desc->Bytes / sizeof(*iavalue); ++l)
1083         {
1084             if (iavalue[l] != get_int(res_desc->Type, &res_value[l])) ++err;
1085         }
1086
1087         for (l = res_desc->Bytes / sizeof(*iavalue); l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1088         {
1089             if (iavalue[l] != 0xabababab) ++err;
1090         }
1091     }
1092     else
1093     {
1094         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetIntArray failed, got %#x, expected %#x\n",
1095                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1096
1097         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (iavalue[l] != 0xabababab) ++err;
1098     }
1099     ok(!err, "%u - %s: GetIntArray failed with %u errors\n", i, res_full_name, err);
1100 }
1101
1102 static void test_effect_parameter_value_GetFloat(const struct test_effect_parameter_value_result *res,
1103         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1104 {
1105     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1106     LPCSTR res_full_name = res->full_name;
1107     HRESULT hr;
1108     DWORD cmp = 0xabababab;
1109     FLOAT fvalue = *(FLOAT *)&cmp;
1110
1111     hr = effect->lpVtbl->GetFloat(effect, parameter, &fvalue);
1112     if (!res_desc->Elements && res_desc->Columns == 1 && res_desc->Rows == 1)
1113     {
1114         ok(hr == D3D_OK, "%u - %s: GetFloat failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1115         ok(compare_float(fvalue, get_float(res_desc->Type, res_value), 512), "%u - %s: GetFloat fvalue failed, got %f, expected %f\n",
1116                 i, res_full_name, fvalue, get_float(res_desc->Type, res_value));
1117     }
1118     else
1119     {
1120         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloat failed, got %#x, expected %#x\n",
1121                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1122         ok(fvalue == *(FLOAT *)&cmp, "%u - %s: GetFloat fvalue failed, got %f, expected %f\n",
1123                 i, res_full_name, fvalue, *(FLOAT *)&cmp);
1124     }
1125 }
1126
1127 static void test_effect_parameter_value_GetFloatArray(const struct test_effect_parameter_value_result *res,
1128         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1129 {
1130     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1131     LPCSTR res_full_name = res->full_name;
1132     FLOAT favalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1133     HRESULT hr;
1134     UINT l, err = 0;
1135     DWORD cmp = 0xabababab;
1136
1137     memset(favalue, 0xab, sizeof(favalue));
1138     hr = effect->lpVtbl->GetFloatArray(effect, parameter, favalue, res_desc->Bytes / sizeof(*favalue));
1139     if (res_desc->Class == D3DXPC_SCALAR
1140             || res_desc->Class == D3DXPC_VECTOR
1141             || res_desc->Class == D3DXPC_MATRIX_ROWS)
1142     {
1143         ok(hr == D3D_OK, "%u - %s: GetFloatArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1144
1145         for (l = 0; l < res_desc->Bytes / sizeof(*favalue); ++l)
1146         {
1147             if (!compare_float(favalue[l], get_float(res_desc->Type, &res_value[l]), 512)) ++err;
1148         }
1149
1150         for (l = res_desc->Bytes / sizeof(*favalue); l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
1151         {
1152             if (favalue[l] != *(FLOAT *)&cmp) ++err;
1153         }
1154     }
1155     else
1156     {
1157         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloatArray failed, got %#x, expected %#x\n",
1158                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1159
1160         for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (favalue[l] != *(FLOAT *)&cmp) ++err;
1161     }
1162     ok(!err, "%u - %s: GetFloatArray failed with %u errors\n", i, res_full_name, err);
1163 }
1164
1165 static void test_effect_parameter_value_GetVector(const struct test_effect_parameter_value_result *res,
1166         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1167 {
1168     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1169     LPCSTR res_full_name = res->full_name;
1170     HRESULT hr;
1171     DWORD cmp = 0xabababab;
1172     FLOAT fvalue[4];
1173     UINT l, err = 0;
1174
1175     memset(fvalue, 0xab, sizeof(fvalue));
1176     hr = effect->lpVtbl->GetVector(effect, parameter, (D3DXVECTOR4 *)&fvalue);
1177     if (!res_desc->Elements &&
1178             (res_desc->Class == D3DXPC_SCALAR || res_desc->Class == D3DXPC_VECTOR) &&
1179             res_desc->Type == D3DXPT_INT && res_desc->Bytes == 4)
1180     {
1181         DWORD tmp;
1182
1183         ok(hr == D3D_OK, "%u - %s: GetVector failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1184
1185         tmp = (DWORD)(*(fvalue + 2) * INT_FLOAT_MULTI);
1186         tmp += ((DWORD)(*(fvalue + 1) * INT_FLOAT_MULTI)) << 8;
1187         tmp += ((DWORD)(*fvalue * INT_FLOAT_MULTI)) << 16;
1188         tmp += ((DWORD)(*(fvalue + 3) * INT_FLOAT_MULTI)) << 24;
1189
1190         if (*res_value != tmp) ++err;
1191     }
1192     else if (!res_desc->Elements && (res_desc->Class == D3DXPC_SCALAR || res_desc->Class == D3DXPC_VECTOR))
1193     {
1194         ok(hr == D3D_OK, "%u - %s: GetVector failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1195
1196         for (l = 0; l < res_desc->Columns; ++l)
1197         {
1198             if (!compare_float(fvalue[l], get_float(res_desc->Type, &res_value[l]), 512)) ++err;
1199         }
1200
1201         for (l = res_desc->Columns; l < 4; ++l) if (fvalue[l] != 0.0f) ++err;
1202     }
1203     else
1204     {
1205         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetVector failed, got %#x, expected %#x\n",
1206                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1207
1208         for (l = 0; l < 4; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1209     }
1210     ok(!err, "%u - %s: GetVector failed with %u errors\n", i, res_full_name, err);
1211 }
1212
1213 static void test_effect_parameter_value_GetVectorArray(const struct test_effect_parameter_value_result *res,
1214         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1215 {
1216     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1217     LPCSTR res_full_name = res->full_name;
1218     HRESULT hr;
1219     DWORD cmp = 0xabababab;
1220     FLOAT fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1221     UINT l, k, element, err = 0;
1222
1223     for (element = 0; element <= res_desc->Elements + 1; ++element)
1224     {
1225         memset(fvalue, 0xab, sizeof(fvalue));
1226         hr = effect->lpVtbl->GetVectorArray(effect, parameter, (D3DXVECTOR4 *)&fvalue, element);
1227         if (!element)
1228         {
1229             ok(hr == D3D_OK, "%u - %s[%u]: GetVectorArray failed, got %#x, expected %#x\n", i, res_full_name, element, hr, D3D_OK);
1230
1231             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1232         }
1233         else if (element <= res_desc->Elements && res_desc->Class == D3DXPC_VECTOR)
1234         {
1235             ok(hr == D3D_OK, "%u - %s[%u]: GetVectorArray failed, got %#x, expected %#x\n", i, res_full_name, element, hr, D3D_OK);
1236
1237             for (k = 0; k < element; ++k)
1238             {
1239                 for (l = 0; l < res_desc->Columns; ++l)
1240                 {
1241                     if (!compare_float(fvalue[l + k * 4], get_float(res_desc->Type,
1242                             &res_value[l + k * res_desc->Columns]), 512))
1243                         ++err;
1244                 }
1245
1246                 for (l = res_desc->Columns; l < 4; ++l) if (fvalue[l + k * 4] != 0.0f) ++err;
1247             }
1248
1249             for (l = element * 4; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1250         }
1251         else
1252         {
1253             ok(hr == D3DERR_INVALIDCALL, "%u - %s[%u]: GetVectorArray failed, got %#x, expected %#x\n",
1254                     i, res_full_name, element, hr, D3DERR_INVALIDCALL);
1255
1256             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1257         }
1258         ok(!err, "%u - %s[%u]: GetVectorArray failed with %u errors\n", i, res_full_name, element, err);
1259     }
1260 }
1261
1262 static void test_effect_parameter_value_GetMatrix(const struct test_effect_parameter_value_result *res,
1263         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1264 {
1265     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1266     LPCSTR res_full_name = res->full_name;
1267     HRESULT hr;
1268     DWORD cmp = 0xabababab;
1269     FLOAT fvalue[16];
1270     UINT l, k, err = 0;
1271
1272     memset(fvalue, 0xab, sizeof(fvalue));
1273     hr = effect->lpVtbl->GetMatrix(effect, parameter, (D3DXMATRIX *)&fvalue);
1274     if (!res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1275     {
1276         ok(hr == D3D_OK, "%u - %s: GetMatrix failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1277
1278         for (k = 0; k < 4; ++k)
1279         {
1280             for (l = 0; l < 4; ++l)
1281             {
1282                 if (k < res_desc->Columns && l < res_desc->Rows)
1283                 {
1284                     if (!compare_float(fvalue[l * 4 + k], get_float(res_desc->Type,
1285                             &res_value[l * res_desc->Columns + k]), 512))
1286                         ++err;
1287                 }
1288                 else if (fvalue[l * 4 + k] != 0.0f) ++err;
1289             }
1290         }
1291     }
1292     else
1293     {
1294         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrix failed, got %#x, expected %#x\n",
1295                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1296
1297         for (l = 0; l < sizeof(fvalue) / sizeof(*fvalue); ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1298     }
1299     ok(!err, "%u - %s: GetMatrix failed with %u errors\n", i, res_full_name, err);
1300 }
1301
1302 static void test_effect_parameter_value_GetMatrixArray(const struct test_effect_parameter_value_result *res,
1303         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1304 {
1305     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1306     LPCSTR res_full_name = res->full_name;
1307     HRESULT hr;
1308     DWORD cmp = 0xabababab;
1309     FLOAT fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1310     UINT l, k, m, element, err = 0;
1311
1312     for (element = 0; element <= res_desc->Elements + 1; ++element)
1313     {
1314         memset(fvalue, 0xab, sizeof(fvalue));
1315         hr = effect->lpVtbl->GetMatrixArray(effect, parameter, (D3DXMATRIX *)&fvalue, element);
1316         if (!element)
1317         {
1318             ok(hr == D3D_OK, "%u - %s[%u]: GetMatrixArray failed, got %#x, expected %#x\n", i, res_full_name, element, hr, D3D_OK);
1319
1320             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1321         }
1322         else if (element <= res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1323         {
1324             ok(hr == D3D_OK, "%u - %s[%u]: GetMatrixArray failed, got %#x, expected %#x\n", i, res_full_name, element, hr, D3D_OK);
1325
1326             for (m = 0; m < element; ++m)
1327             {
1328                 for (k = 0; k < 4; ++k)
1329                 {
1330                     for (l = 0; l < 4; ++l)
1331                     {
1332                         if (k < res_desc->Columns && l < res_desc->Rows)
1333                         {
1334                             if (!compare_float(fvalue[m * 16 + l * 4 + k], get_float(res_desc->Type,
1335                                     &res_value[m * res_desc->Columns * res_desc->Rows + l * res_desc->Columns + k]), 512))
1336                                 ++err;
1337                         }
1338                         else if (fvalue[m * 16 + l * 4 + k] != 0.0f) ++err;
1339                     }
1340                 }
1341             }
1342
1343             for (l = element * 16; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1344         }
1345         else
1346         {
1347             ok(hr == D3DERR_INVALIDCALL, "%u - %s[%u]: GetMatrixArray failed, got %#x, expected %#x\n",
1348                     i, res_full_name, element, hr, D3DERR_INVALIDCALL);
1349
1350             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1351         }
1352         ok(!err, "%u - %s[%u]: GetMatrixArray failed with %u errors\n", i, res_full_name, element, err);
1353     }
1354 }
1355
1356 static void test_effect_parameter_value_GetMatrixPointerArray(const struct test_effect_parameter_value_result *res,
1357         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1358 {
1359     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1360     LPCSTR res_full_name = res->full_name;
1361     HRESULT hr;
1362     DWORD cmp = 0xabababab;
1363     FLOAT fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1364     D3DXMATRIX *matrix_pointer_array[sizeof(fvalue)/sizeof(D3DXMATRIX)];
1365     UINT l, k, m, element, err = 0;
1366
1367     for (element = 0; element <= res_desc->Elements + 1; ++element)
1368     {
1369         memset(fvalue, 0xab, sizeof(fvalue));
1370         for (l = 0; l < element; ++l)
1371         {
1372             matrix_pointer_array[l] = (D3DXMATRIX *)&fvalue[l * sizeof(**matrix_pointer_array) / sizeof(FLOAT)];
1373         }
1374         hr = effect->lpVtbl->GetMatrixPointerArray(effect, parameter, matrix_pointer_array, element);
1375         if (!element)
1376         {
1377             ok(hr == D3D_OK, "%u - %s[%u]: GetMatrixPointerArray failed, got %#x, expected %#x\n",
1378                     i, res_full_name, element, hr, D3D_OK);
1379
1380             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1381         }
1382         else if (element <= res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1383         {
1384             ok(hr == D3D_OK, "%u - %s[%u]: GetMatrixPointerArray failed, got %#x, expected %#x\n",
1385                     i, res_full_name, element, hr, D3D_OK);
1386
1387             for (m = 0; m < element; ++m)
1388             {
1389                 for (k = 0; k < 4; ++k)
1390                 {
1391                     for (l = 0; l < 4; ++l)
1392                     {
1393                         if (k < res_desc->Columns && l < res_desc->Rows)
1394                         {
1395                             if (!compare_float(fvalue[m * 16 + l * 4 + k], get_float(res_desc->Type,
1396                                     &res_value[m * res_desc->Columns * res_desc->Rows + l * res_desc->Columns + k]), 512))
1397                                 ++err;
1398                         }
1399                         else if (fvalue[m * 16 + l * 4 + k] != 0.0f) ++err;
1400                     }
1401                 }
1402             }
1403
1404             for (l = element * 16; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1405         }
1406         else
1407         {
1408             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1409
1410             ok(hr == D3DERR_INVALIDCALL, "%u - %s[%u]: GetMatrixPointerArray failed, got %#x, expected %#x\n",
1411                     i, res_full_name, element, hr, D3DERR_INVALIDCALL);
1412         }
1413         ok(!err, "%u - %s[%u]: GetMatrixPointerArray failed with %u errors\n", i, res_full_name, element, err);
1414     }
1415 }
1416
1417 static void test_effect_parameter_value_GetMatrixTranspose(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[16];
1425     UINT l, k, err = 0;
1426
1427     memset(fvalue, 0xab, sizeof(fvalue));
1428     hr = effect->lpVtbl->GetMatrixTranspose(effect, parameter, (D3DXMATRIX *)&fvalue);
1429     if (!res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1430     {
1431         ok(hr == D3D_OK, "%u - %s: GetMatrixTranspose failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1432
1433         for (k = 0; k < 4; ++k)
1434         {
1435             for (l = 0; l < 4; ++l)
1436             {
1437                 if (k < res_desc->Columns && l < res_desc->Rows)
1438                 {
1439                     if (!compare_float(fvalue[l + k * 4], get_float(res_desc->Type,
1440                             &res_value[l * res_desc->Columns + k]), 512))
1441                         ++err;
1442                 }
1443                 else if (fvalue[l + k * 4] != 0.0f) ++err;
1444             }
1445         }
1446     }
1447     else if (!res_desc->Elements && (res_desc->Class == D3DXPC_VECTOR || res_desc->Class == D3DXPC_SCALAR))
1448     {
1449         ok(hr == D3D_OK, "%u - %s: GetMatrixTranspose failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1450
1451         for (k = 0; k < 4; ++k)
1452         {
1453             for (l = 0; l < 4; ++l)
1454             {
1455                 if (k < res_desc->Columns && l < res_desc->Rows)
1456                 {
1457                     if (!compare_float(fvalue[l * 4 + k], get_float(res_desc->Type,
1458                             &res_value[l * res_desc->Columns + k]), 512))
1459                         ++err;
1460                 }
1461                 else if (fvalue[l * 4 + k] != 0.0f) ++err;
1462             }
1463         }
1464     }
1465     else
1466     {
1467         ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTranspose failed, got %#x, expected %#x\n",
1468                 i, res_full_name, hr, D3DERR_INVALIDCALL);
1469
1470         for (l = 0; l < sizeof(fvalue) / sizeof(*fvalue); ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1471     }
1472     ok(!err, "%u - %s: GetMatrixTranspose failed with %u errors\n", i, res_full_name, err);
1473 }
1474
1475 static void test_effect_parameter_value_GetMatrixTransposeArray(const struct test_effect_parameter_value_result *res,
1476         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1477 {
1478     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1479     LPCSTR res_full_name = res->full_name;
1480     HRESULT hr;
1481     DWORD cmp = 0xabababab;
1482     FLOAT fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1483     UINT l, k, m, element, err = 0;
1484
1485     for (element = 0; element <= res_desc->Elements + 1; ++element)
1486     {
1487         memset(fvalue, 0xab, sizeof(fvalue));
1488         hr = effect->lpVtbl->GetMatrixTransposeArray(effect, parameter, (D3DXMATRIX *)&fvalue, element);
1489         if (!element)
1490         {
1491             ok(hr == D3D_OK, "%u - %s[%u]: GetMatrixTransposeArray failed, got %#x, expected %#x\n",
1492                     i, res_full_name, element, hr, D3D_OK);
1493
1494             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1495         }
1496         else if (element <= res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1497         {
1498             ok(hr == D3D_OK, "%u - %s[%u]: GetMatrixTransposeArray failed, got %#x, expected %#x\n",
1499                     i, res_full_name, element, hr, D3D_OK);
1500
1501             for (m = 0; m < element; ++m)
1502             {
1503                 for (k = 0; k < 4; ++k)
1504                 {
1505                     for (l = 0; l < 4; ++l)
1506                     {
1507                         if (k < res_desc->Columns && l < res_desc->Rows)
1508                         {
1509                             if (!compare_float(fvalue[m * 16 + l + k * 4], get_float(res_desc->Type,
1510                                     &res_value[m * res_desc->Columns * res_desc->Rows + l * res_desc->Columns + k]), 512))
1511                                 ++err;
1512                         }
1513                         else if (fvalue[m * 16 + l + k * 4] != 0.0f) ++err;
1514                     }
1515                 }
1516             }
1517
1518             for (l = element * 16; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1519         }
1520         else
1521         {
1522             ok(hr == D3DERR_INVALIDCALL, "%u - %s[%u]: GetMatrixTransposeArray failed, got %#x, expected %#x\n",
1523                     i, res_full_name, element, hr, D3DERR_INVALIDCALL);
1524
1525             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1526         }
1527         ok(!err, "%u - %s[%u]: GetMatrixTransposeArray failed with %u errors\n", i, res_full_name, element, err);
1528     }
1529 }
1530
1531 static void test_effect_parameter_value_GetMatrixTransposePointerArray(const struct test_effect_parameter_value_result *res,
1532         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1533 {
1534     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1535     LPCSTR res_full_name = res->full_name;
1536     HRESULT hr;
1537     DWORD cmp = 0xabababab;
1538     FLOAT fvalue[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1539     D3DXMATRIX *matrix_pointer_array[sizeof(fvalue)/sizeof(D3DXMATRIX)];
1540     UINT l, k, m, element, err = 0;
1541
1542     for (element = 0; element <= res_desc->Elements + 1; ++element)
1543     {
1544         memset(fvalue, 0xab, sizeof(fvalue));
1545         for (l = 0; l < element; ++l)
1546         {
1547             matrix_pointer_array[l] = (D3DXMATRIX *)&fvalue[l * sizeof(**matrix_pointer_array) / sizeof(FLOAT)];
1548         }
1549         hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, parameter, matrix_pointer_array, element);
1550         if (!element)
1551         {
1552             ok(hr == D3D_OK, "%u - %s[%u]: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
1553                     i, res_full_name, element, hr, D3D_OK);
1554
1555             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1556         }
1557         else if (element <= res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
1558         {
1559             ok(hr == D3D_OK, "%u - %s[%u]: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
1560                     i, res_full_name, element, hr, D3D_OK);
1561
1562             for (m = 0; m < element; ++m)
1563             {
1564                 for (k = 0; k < 4; ++k)
1565                 {
1566                     for (l = 0; l < 4; ++l)
1567                     {
1568                         if (k < res_desc->Columns && l < res_desc->Rows)
1569                         {
1570                             if (!compare_float(fvalue[m * 16 + l + k * 4], get_float(res_desc->Type,
1571                                     &res_value[m * res_desc->Columns * res_desc->Rows + l * res_desc->Columns + k]), 512))
1572                                 ++err;
1573                         }
1574                         else if (fvalue[m * 16 + l + k * 4] != 0.0f) ++err;
1575                     }
1576                 }
1577             }
1578
1579             for (l = element * 16; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1580         }
1581         else
1582         {
1583             ok(hr == D3DERR_INVALIDCALL, "%u - %s[%u]: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
1584                     i, res_full_name, element, hr, D3DERR_INVALIDCALL);
1585
1586             for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l) if (fvalue[l] != *(FLOAT *)&cmp) ++err;
1587         }
1588         ok(!err, "%u - %s[%u]: GetMatrixTransposePointerArray failed with %u errors\n", i, res_full_name, element, err);
1589     }
1590 }
1591
1592 static void test_effect_parameter_value_GetTestGroup(const struct test_effect_parameter_value_result *res,
1593         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1594 {
1595     test_effect_parameter_value_GetValue(res, effect, res_value, parameter, i);
1596     test_effect_parameter_value_GetBool(res, effect, res_value, parameter, i);
1597     test_effect_parameter_value_GetBoolArray(res, effect, res_value, parameter, i);
1598     test_effect_parameter_value_GetInt(res, effect, res_value, parameter, i);
1599     test_effect_parameter_value_GetIntArray(res, effect, res_value, parameter, i);
1600     test_effect_parameter_value_GetFloat(res, effect, res_value, parameter, i);
1601     test_effect_parameter_value_GetFloatArray(res, effect, res_value, parameter, i);
1602     test_effect_parameter_value_GetVector(res, effect, res_value, parameter, i);
1603     test_effect_parameter_value_GetVectorArray(res, effect, res_value, parameter, i);
1604     test_effect_parameter_value_GetMatrix(res, effect, res_value, parameter, i);
1605     test_effect_parameter_value_GetMatrixArray(res, effect, res_value, parameter, i);
1606     test_effect_parameter_value_GetMatrixPointerArray(res, effect, res_value, parameter, i);
1607     test_effect_parameter_value_GetMatrixTranspose(res, effect, res_value, parameter, i);
1608     test_effect_parameter_value_GetMatrixTransposeArray(res, effect, res_value, parameter, i);
1609     test_effect_parameter_value_GetMatrixTransposePointerArray(res, effect, res_value, parameter, i);
1610 }
1611
1612 static void test_effect_parameter_value_ResetValue(const struct test_effect_parameter_value_result *res,
1613         ID3DXEffect *effect, const DWORD *res_value, D3DXHANDLE parameter, UINT i)
1614 {
1615     const D3DXPARAMETER_DESC *res_desc = &res->desc;
1616     LPCSTR res_full_name = res->full_name;
1617     HRESULT hr;
1618
1619     if (res_desc->Class == D3DXPC_SCALAR
1620             || res_desc->Class == D3DXPC_VECTOR
1621             || res_desc->Class == D3DXPC_MATRIX_ROWS)
1622     {
1623         hr = effect->lpVtbl->SetValue(effect, parameter, res_value, res_desc->Bytes);
1624         ok(hr == D3D_OK, "%u - %s: SetValue failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1625     }
1626     else
1627     {
1628         /* nothing to do */
1629         switch (res_desc->Type)
1630         {
1631             case D3DXPT_PIXELSHADER:
1632             case D3DXPT_VERTEXSHADER:
1633             case D3DXPT_TEXTURE2D:
1634             case D3DXPT_STRING:
1635                 break;
1636
1637             default:
1638                 ok(0, "Type is %u, this should not happen!\n", res_desc->Type);
1639                 break;
1640         }
1641     }
1642 }
1643
1644 static void test_effect_parameter_value(IDirect3DDevice9 *device)
1645 {
1646     UINT i;
1647     UINT effect_count = sizeof(test_effect_parameter_value_data) / sizeof(*test_effect_parameter_value_data);
1648
1649     for (i = 0; i < effect_count; ++i)
1650     {
1651         const struct test_effect_parameter_value_result *res = test_effect_parameter_value_data[i].res;
1652         UINT res_count = test_effect_parameter_value_data[i].res_count;
1653         const DWORD *blob = test_effect_parameter_value_data[i].blob;
1654         UINT blob_size = test_effect_parameter_value_data[i].blob_size;
1655         HRESULT hr;
1656         ID3DXEffect *effect;
1657         D3DXEFFECT_DESC edesc;
1658         ULONG count;
1659         UINT k;
1660
1661         hr = D3DXCreateEffect(device, blob, blob_size, NULL, NULL, 0, NULL, &effect, NULL);
1662         ok(hr == D3D_OK, "%u: D3DXCreateEffect failed, got %#x, expected %#x\n", i, hr, D3D_OK);
1663
1664         hr = effect->lpVtbl->GetDesc(effect, &edesc);
1665         ok(hr == D3D_OK, "%u: GetDesc failed, got %#x, expected %#x\n", i, hr, D3D_OK);
1666         ok(edesc.Parameters == res_count, "%u: Parameters failed, got %u, expected %u\n",
1667                 i, edesc.Parameters, res_count);
1668
1669         for (k = 0; k < res_count; ++k)
1670         {
1671             const D3DXPARAMETER_DESC *res_desc = &res[k].desc;
1672             LPCSTR res_full_name = res[k].full_name;
1673             UINT res_value_offset = res[k].value_offset;
1674             D3DXHANDLE parameter;
1675             D3DXPARAMETER_DESC pdesc;
1676             BOOL bvalue;
1677             INT ivalue;
1678             FLOAT fvalue;
1679             DWORD input_value[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1680             DWORD expected_value[EFFECT_PARAMETER_VALUE_ARRAY_SIZE];
1681             UINT l, n, m, element;
1682             const D3DXMATRIX *matrix_pointer_array[sizeof(input_value)/sizeof(D3DXMATRIX)];
1683
1684             parameter = effect->lpVtbl->GetParameterByName(effect, NULL, res_full_name);
1685             ok(parameter != NULL, "%u - %s: GetParameterByName failed\n", i, res_full_name);
1686
1687             hr = effect->lpVtbl->GetParameterDesc(effect, parameter, &pdesc);
1688             ok(hr == D3D_OK, "%u - %s: GetParameterDesc failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1689
1690             ok(res_desc->Name ? !strcmp(pdesc.Name, res_desc->Name) : !pdesc.Name,
1691                     "%u - %s: GetParameterDesc Name failed, got \"%s\", expected \"%s\"\n",
1692                     i, res_full_name, pdesc.Name, res_desc->Name);
1693             ok(res_desc->Semantic ? !strcmp(pdesc.Semantic, res_desc->Semantic) : !pdesc.Semantic,
1694                     "%u - %s: GetParameterDesc Semantic failed, got \"%s\", expected \"%s\"\n",
1695                     i, res_full_name, pdesc.Semantic, res_desc->Semantic);
1696             ok(res_desc->Class == pdesc.Class, "%u - %s: GetParameterDesc Class failed, got %#x, expected %#x\n",
1697                     i, res_full_name, pdesc.Class, res_desc->Class);
1698             ok(res_desc->Type == pdesc.Type, "%u - %s: GetParameterDesc Type failed, got %#x, expected %#x\n",
1699                     i, res_full_name, pdesc.Type, res_desc->Type);
1700             ok(res_desc->Rows == pdesc.Rows, "%u - %s: GetParameterDesc Rows failed, got %u, expected %u\n",
1701                     i, res_full_name, pdesc.Rows, res_desc->Rows);
1702             ok(res_desc->Columns == pdesc.Columns, "%u - %s: GetParameterDesc Columns failed, got %u, expected %u\n",
1703                     i, res_full_name, pdesc.Columns, res_desc->Columns);
1704             ok(res_desc->Elements == pdesc.Elements, "%u - %s: GetParameterDesc Elements failed, got %u, expected %u\n",
1705                     i, res_full_name, pdesc.Elements, res_desc->Elements);
1706             ok(res_desc->Annotations == pdesc.Annotations, "%u - %s: GetParameterDesc Annotations failed, got %u, expected %u\n",
1707                     i, res_full_name, pdesc.Annotations, res_desc->Annotations);
1708             ok(res_desc->StructMembers == pdesc.StructMembers, "%u - %s: GetParameterDesc StructMembers failed, got %u, expected %u\n",
1709                     i, res_full_name, pdesc.StructMembers, res_desc->StructMembers);
1710             ok(res_desc->Flags == pdesc.Flags, "%u - %s: GetParameterDesc Flags failed, got %u, expected %u\n",
1711                     i, res_full_name, pdesc.Flags, res_desc->Flags);
1712             ok(res_desc->Bytes == pdesc.Bytes, "%u - %s: GetParameterDesc Bytes, got %u, expected %u\n",
1713                     i, res_full_name, pdesc.Bytes, res_desc->Bytes);
1714
1715             /* check size */
1716             ok(EFFECT_PARAMETER_VALUE_ARRAY_SIZE >= res_desc->Bytes / 4 +
1717                     (res_desc->Elements ? res_desc->Bytes / 4 / res_desc->Elements : 0),
1718                     "%u - %s: Warning: Array size to small\n", i, res_full_name);
1719
1720             test_effect_parameter_value_GetTestGroup(&res[k], effect, &blob[res_value_offset], parameter, i);
1721             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
1722             test_effect_parameter_value_GetTestGroup(&res[k], effect, &blob[res_value_offset], parameter, i);
1723
1724             /*
1725              * check invalid calls
1726              * These will crash:
1727              * effect->lpVtbl->SetBoolArray(effect, parameter, NULL, res_desc->Bytes / sizeof(BOOL));
1728              * effect->lpVtbl->SetIntArray(effect, parameter, NULL, res_desc->Bytes / sizeof(INT));
1729              * effect->lpVtbl->SetFloatArray(effect, parameter, NULL, res_desc->Bytes / sizeof(FLOAT));
1730              * effect->lpVtbl->SetVector(effect, parameter, NULL);
1731              * effect->lpVtbl->SetVectorArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1732              * effect->lpVtbl->SetMatrix(effect, parameter, NULL);
1733              * effect->lpVtbl->GetMatrix(effect, parameter, NULL);
1734              * effect->lpVtbl->SetMatrixArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1735              * effect->lpVtbl->SetMatrixPointerArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1736              * effect->lpVtbl->SetMatrixTranspose(effect, parameter, NULL);
1737              * effect->lpVtbl->SetMatrixTransposeArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1738              * effect->lpVtbl->SetMatrixTransposePointerArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1739              * effect->lpVtbl->GetValue(effect, parameter, NULL, res_desc->Bytes);
1740              * effect->lpVtbl->SetValue(effect, parameter, NULL, res_desc->Bytes);
1741              */
1742             hr = effect->lpVtbl->SetBool(effect, NULL, bvalue);
1743             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetBool failed, got %#x, expected %#x\n",
1744                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1745
1746             hr = effect->lpVtbl->GetBool(effect, NULL, &bvalue);
1747             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetBool failed, got %#x, expected %#x\n",
1748                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1749
1750             hr = effect->lpVtbl->GetBool(effect, parameter, NULL);
1751             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetBool failed, got %#x, expected %#x\n",
1752                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1753
1754             hr = effect->lpVtbl->SetBoolArray(effect, NULL, (BOOL *)input_value, res_desc->Bytes / sizeof(BOOL));
1755             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetBoolArray failed, got %#x, expected %#x\n",
1756                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1757
1758             hr = effect->lpVtbl->GetBoolArray(effect, NULL, (BOOL *)input_value, res_desc->Bytes / sizeof(BOOL));
1759             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetBoolArray failed, got %#x, expected %#x\n",
1760                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1761
1762             hr = effect->lpVtbl->GetBoolArray(effect, parameter, NULL, res_desc->Bytes / sizeof(BOOL));
1763             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetBoolArray failed, got %#x, expected %#x\n",
1764                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1765
1766             hr = effect->lpVtbl->SetInt(effect, NULL, ivalue);
1767             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetInt failed, got %#x, expected %#x\n",
1768                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1769
1770             hr = effect->lpVtbl->GetInt(effect, NULL, &ivalue);
1771             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetInt failed, got %#x, expected %#x\n",
1772                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1773
1774             hr = effect->lpVtbl->GetInt(effect, parameter, NULL);
1775             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetInt failed, got %#x, expected %#x\n",
1776                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1777
1778             hr = effect->lpVtbl->SetIntArray(effect, NULL, (INT *)input_value, res_desc->Bytes / sizeof(INT));
1779             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetIntArray failed, got %#x, expected %#x\n",
1780                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1781
1782             hr = effect->lpVtbl->GetIntArray(effect, NULL, (INT *)input_value, res_desc->Bytes / sizeof(INT));
1783             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetIntArray failed, got %#x, expected %#x\n",
1784                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1785
1786             hr = effect->lpVtbl->GetIntArray(effect, parameter, NULL, res_desc->Bytes / sizeof(INT));
1787             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetIntArray failed, got %#x, expected %#x\n",
1788                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1789
1790             hr = effect->lpVtbl->SetFloat(effect, NULL, fvalue);
1791             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetFloat failed, got %#x, expected %#x\n",
1792                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1793
1794             hr = effect->lpVtbl->GetFloat(effect, NULL, &fvalue);
1795             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloat failed, got %#x, expected %#x\n",
1796                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1797
1798             hr = effect->lpVtbl->GetFloat(effect, parameter, NULL);
1799             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloat failed, got %#x, expected %#x\n",
1800                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1801
1802             hr = effect->lpVtbl->SetFloatArray(effect, NULL, (FLOAT *)input_value, res_desc->Bytes / sizeof(FLOAT));
1803             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetFloatArray failed, got %#x, expected %#x\n",
1804                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1805
1806             hr = effect->lpVtbl->GetFloatArray(effect, NULL, (FLOAT *)input_value, res_desc->Bytes / sizeof(FLOAT));
1807             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloatArray failed, got %#x, expected %#x\n",
1808                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1809
1810             hr = effect->lpVtbl->GetFloatArray(effect, parameter, NULL, res_desc->Bytes / sizeof(FLOAT));
1811             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetFloatArray failed, got %#x, expected %#x\n",
1812                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1813
1814             hr = effect->lpVtbl->SetVector(effect, NULL, (D3DXVECTOR4 *)input_value);
1815             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetVector failed, got %#x, expected %#x\n",
1816                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1817
1818             hr = effect->lpVtbl->GetVector(effect, NULL, (D3DXVECTOR4 *)input_value);
1819             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetVector failed, got %#x, expected %#x\n",
1820                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1821
1822             hr = effect->lpVtbl->GetVector(effect, parameter, NULL);
1823             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetVector failed, got %#x, expected %#x\n",
1824                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1825
1826             hr = effect->lpVtbl->SetVectorArray(effect, NULL, (D3DXVECTOR4 *)input_value, res_desc->Elements ? res_desc->Elements : 1);
1827             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetVectorArray failed, got %#x, expected %#x\n",
1828                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1829
1830             hr = effect->lpVtbl->GetVectorArray(effect, NULL, (D3DXVECTOR4 *)input_value, res_desc->Elements ? res_desc->Elements : 1);
1831             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetVectorArray failed, got %#x, expected %#x\n",
1832                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1833
1834             hr = effect->lpVtbl->GetVectorArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1835             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetVectorArray failed, got %#x, expected %#x\n",
1836                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1837
1838             hr = effect->lpVtbl->SetMatrix(effect, NULL, (D3DXMATRIX *)input_value);
1839             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrix failed, got %#x, expected %#x\n",
1840                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1841
1842             hr = effect->lpVtbl->GetMatrix(effect, NULL, (D3DXMATRIX *)input_value);
1843             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrix failed, got %#x, expected %#x\n",
1844                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1845
1846             hr = effect->lpVtbl->SetMatrixArray(effect, NULL, (D3DXMATRIX *)input_value, res_desc->Elements ? res_desc->Elements : 1);
1847             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixArray failed, got %#x, expected %#x\n",
1848                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1849
1850             hr = effect->lpVtbl->GetMatrixArray(effect, NULL, (D3DXMATRIX *)input_value, res_desc->Elements ? res_desc->Elements : 1);
1851             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixArray failed, got %#x, expected %#x\n",
1852                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1853
1854             hr = effect->lpVtbl->GetMatrixArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1855             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixArray failed, got %#x, expected %#x\n",
1856                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1857
1858             hr = effect->lpVtbl->SetMatrixPointerArray(effect, NULL, matrix_pointer_array, res_desc->Elements ? res_desc->Elements : 1);
1859             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixPointerArray failed, got %#x, expected %#x\n",
1860                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1861
1862             hr = effect->lpVtbl->SetMatrixPointerArray(effect, NULL, matrix_pointer_array, 0);
1863             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixPointerArray failed, got %#x, expected %#x\n",
1864                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1865
1866             hr = effect->lpVtbl->GetMatrixPointerArray(effect, NULL, NULL, 0);
1867             ok(hr == D3D_OK, "%u - %s: GetMatrixPointerArray failed, got %#x, expected %#x\n",
1868                     i, res_full_name, hr, D3D_OK);
1869
1870             hr = effect->lpVtbl->GetMatrixPointerArray(effect, NULL, NULL, res_desc->Elements ? res_desc->Elements : 1);
1871             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixPointerArray failed, got %#x, expected %#x\n",
1872                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1873
1874             hr = effect->lpVtbl->GetMatrixPointerArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1875             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixPointerArray failed, got %#x, expected %#x\n",
1876                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1877
1878             hr = effect->lpVtbl->SetMatrixTranspose(effect, NULL, (D3DXMATRIX *)input_value);
1879             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTranspose failed, got %#x, expected %#x\n",
1880                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1881
1882             hr = effect->lpVtbl->GetMatrixTranspose(effect, NULL, (D3DXMATRIX *)input_value);
1883             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTranspose failed, got %#x, expected %#x\n",
1884                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1885
1886             hr = effect->lpVtbl->GetMatrixTranspose(effect, parameter, NULL);
1887             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTranspose failed, got %#x, expected %#x\n",
1888                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1889
1890             hr = effect->lpVtbl->SetMatrixTransposeArray(effect, NULL, (D3DXMATRIX *)input_value, res_desc->Elements ? res_desc->Elements : 1);
1891             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTransposeArray failed, got %#x, expected %#x\n",
1892                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1893
1894             hr = effect->lpVtbl->GetMatrixTransposeArray(effect, NULL, (D3DXMATRIX *)input_value, res_desc->Elements ? res_desc->Elements : 1);
1895             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTransposeArray failed, got %#x, expected %#x\n",
1896                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1897
1898             hr = effect->lpVtbl->GetMatrixTransposeArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1899             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTransposeArray failed, got %#x, expected %#x\n",
1900                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1901
1902             hr = effect->lpVtbl->SetMatrixTransposePointerArray(effect, NULL, matrix_pointer_array, res_desc->Elements ? res_desc->Elements : 1);
1903             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
1904                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1905
1906             hr = effect->lpVtbl->SetMatrixTransposePointerArray(effect, NULL, matrix_pointer_array, 0);
1907             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
1908                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1909
1910             hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, NULL, NULL, 0);
1911             ok(hr == D3D_OK, "%u - %s: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
1912                     i, res_full_name, hr, D3D_OK);
1913
1914             hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, NULL, NULL, res_desc->Elements ? res_desc->Elements : 1);
1915             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
1916                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1917
1918             hr = effect->lpVtbl->GetMatrixTransposePointerArray(effect, parameter, NULL, res_desc->Elements ? res_desc->Elements : 1);
1919             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
1920                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1921
1922             hr = effect->lpVtbl->SetValue(effect, NULL, input_value, res_desc->Bytes);
1923             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetValue failed, got %#x, expected %#x\n",
1924                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1925
1926             hr = effect->lpVtbl->SetValue(effect, parameter, input_value, res_desc->Bytes - 1);
1927             ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetValue failed, got %#x, expected %#x\n",
1928                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1929
1930             hr = effect->lpVtbl->GetValue(effect, NULL, input_value, res_desc->Bytes);
1931             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetValue failed, got %#x, expected %#x\n",
1932                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1933
1934             hr = effect->lpVtbl->GetValue(effect, parameter, input_value, res_desc->Bytes - 1);
1935             ok(hr == D3DERR_INVALIDCALL, "%u - %s: GetValue failed, got %#x, expected %#x\n",
1936                     i, res_full_name, hr, D3DERR_INVALIDCALL);
1937
1938             test_effect_parameter_value_GetTestGroup(&res[k], effect, &blob[res_value_offset], parameter, i);
1939
1940             /* SetBool */
1941             bvalue = 5;
1942             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
1943             hr = effect->lpVtbl->SetBool(effect, parameter, bvalue);
1944             if (!res_desc->Elements && res_desc->Rows == 1 && res_desc->Columns == 1)
1945             {
1946                 bvalue = bvalue ? TRUE : FALSE;
1947                 set_number(expected_value, res_desc->Type, &bvalue, D3DXPT_BOOL);
1948                 ok(hr == D3D_OK, "%u - %s: SetBool failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1949             }
1950             else
1951             {
1952                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetBool failed, got %#x, expected %#x\n",
1953                         i, res_full_name, hr, D3DERR_INVALIDCALL);
1954             }
1955             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
1956             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
1957
1958             /* SetBoolArray */
1959             *input_value = 1;
1960             for (l = 1; l < res_desc->Bytes / sizeof(*input_value); ++l)
1961             {
1962                 *(input_value + l) = *(input_value + l - 1) + 1;
1963             }
1964             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
1965             hr = effect->lpVtbl->SetBoolArray(effect, parameter, (BOOL *)input_value, res_desc->Bytes / sizeof(*input_value));
1966             if (res_desc->Class == D3DXPC_SCALAR
1967                     || res_desc->Class == D3DXPC_VECTOR
1968                     || res_desc->Class == D3DXPC_MATRIX_ROWS)
1969             {
1970                 for (l = 0; l < res_desc->Bytes / sizeof(*input_value); ++l)
1971                 {
1972                     set_number(expected_value + l, res_desc->Type, input_value + l, D3DXPT_BOOL);
1973                 }
1974                 ok(hr == D3D_OK, "%u - %s: SetBoolArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1975             }
1976             else
1977             {
1978                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetBoolArray failed, got %#x, expected %#x\n",
1979                         i, res_full_name, hr, D3DERR_INVALIDCALL);
1980             }
1981             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
1982             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
1983
1984             /* SetInt */
1985             ivalue = 0x1fbf02ff;
1986             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
1987             hr = effect->lpVtbl->SetInt(effect, parameter, ivalue);
1988             if (!res_desc->Elements && res_desc->Rows == 1 && res_desc->Columns == 1)
1989             {
1990                 set_number(expected_value, res_desc->Type, &ivalue, D3DXPT_INT);
1991                 ok(hr == D3D_OK, "%u - %s: SetInt failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
1992             }
1993             else if(!res_desc->Elements && res_desc->Type == D3DXPT_FLOAT &&
1994                     ((res_desc->Class == D3DXPC_VECTOR && res_desc->Columns != 2) ||
1995                     (res_desc->Class == D3DXPC_MATRIX_ROWS && res_desc->Rows != 2 && res_desc->Columns == 1)))
1996             {
1997                 FLOAT tmp = ((ivalue & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE;
1998                 set_number(expected_value, res_desc->Type, &tmp, D3DXPT_FLOAT);
1999                 tmp = ((ivalue & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE;
2000                 set_number(expected_value + 1, res_desc->Type, &tmp, D3DXPT_FLOAT);
2001                 tmp = (ivalue & 0xff) * INT_FLOAT_MULTI_INVERSE;
2002                 set_number(expected_value + 2, res_desc->Type, &tmp, D3DXPT_FLOAT);
2003                 tmp = ((ivalue & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
2004                 set_number(expected_value + 3, res_desc->Type, &tmp, D3DXPT_FLOAT);
2005
2006                 ok(hr == D3D_OK, "%u - %s: SetInt failed, got %#x, expected %#x\n",
2007                         i, res_full_name, hr, D3D_OK);
2008             }
2009             else
2010             {
2011                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetInt failed, got %#x, expected %#x\n",
2012                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2013             }
2014             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2015             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2016
2017             /* SetIntArray */
2018             *input_value = 123456;
2019             for (l = 0; l < res_desc->Bytes / sizeof(*input_value); ++l)
2020             {
2021                 *(input_value + l) = *(input_value + l - 1) + 23;
2022             }
2023             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2024             hr = effect->lpVtbl->SetIntArray(effect, parameter, (INT *)input_value, res_desc->Bytes / sizeof(*input_value));
2025             if (res_desc->Class == D3DXPC_SCALAR
2026                     || res_desc->Class == D3DXPC_VECTOR
2027                     || res_desc->Class == D3DXPC_MATRIX_ROWS)
2028             {
2029                 for (l = 0; l < res_desc->Bytes / sizeof(*input_value); ++l)
2030                 {
2031                     set_number(expected_value + l, res_desc->Type, input_value + l, D3DXPT_INT);
2032                 }
2033                 ok(hr == D3D_OK, "%u - %s: SetIntArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2034             }
2035             else
2036             {
2037                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetIntArray failed, got %#x, expected %#x\n",
2038                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2039             }
2040             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2041             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2042
2043             /* SetFloat */
2044             fvalue = 1.33;
2045             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2046             hr = effect->lpVtbl->SetFloat(effect, parameter, fvalue);
2047             if (!res_desc->Elements && res_desc->Rows == 1 && res_desc->Columns == 1)
2048             {
2049                 set_number(expected_value, res_desc->Type, &fvalue, D3DXPT_FLOAT);
2050                 ok(hr == D3D_OK, "%u - %s: SetFloat failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2051             }
2052             else
2053             {
2054                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetFloat failed, got %#x, expected %#x\n",
2055                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2056             }
2057             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2058             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2059
2060             /* SetFloatArray */
2061             fvalue = 1.33;
2062             for (l = 0; l < res_desc->Bytes / sizeof(fvalue); ++l)
2063             {
2064                 *(input_value + l) = *(DWORD *)&fvalue;
2065                 fvalue += 1.12;
2066             }
2067             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2068             hr = effect->lpVtbl->SetFloatArray(effect, parameter, (FLOAT *)input_value, res_desc->Bytes / sizeof(*input_value));
2069             if (res_desc->Class == D3DXPC_SCALAR
2070                     || res_desc->Class == D3DXPC_VECTOR
2071                     || res_desc->Class == D3DXPC_MATRIX_ROWS)
2072             {
2073                 for (l = 0; l < res_desc->Bytes / sizeof(*input_value); ++l)
2074                 {
2075                     set_number(expected_value + l, res_desc->Type, input_value + l, D3DXPT_FLOAT);
2076                 }
2077                 ok(hr == D3D_OK, "%u - %s: SetFloatArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2078             }
2079             else
2080             {
2081                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetFloatArray failed, got %#x, expected %#x\n",
2082                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2083             }
2084             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2085             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2086
2087             /* SetVector */
2088             fvalue = -1.33;
2089             for (l = 0; l < 4; ++l)
2090             {
2091                 *(input_value + l) = *(DWORD *)&fvalue;
2092                 fvalue += 1.12;
2093             }
2094             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2095             hr = effect->lpVtbl->SetVector(effect, parameter, (D3DXVECTOR4 *)input_value);
2096             if (!res_desc->Elements &&
2097                     (res_desc->Class == D3DXPC_SCALAR
2098                     || res_desc->Class == D3DXPC_VECTOR))
2099             {
2100                 /* only values between 0 and INT_FLOAT_MULTI are valid */
2101                 if (res_desc->Type == D3DXPT_INT && res_desc->Bytes == 4)
2102                 {
2103                     *expected_value = (DWORD)(max(min(*(FLOAT *)(input_value + 2), 1.0f), 0.0f) * INT_FLOAT_MULTI);
2104                     *expected_value += ((DWORD)(max(min(*(FLOAT *)(input_value + 1), 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 8;
2105                     *expected_value += ((DWORD)(max(min(*(FLOAT *)input_value, 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 16;
2106                     *expected_value += ((DWORD)(max(min(*(FLOAT *)(input_value + 3), 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 24;
2107                 }
2108                 else
2109                 {
2110                     for (l = 0; l < 4; ++l)
2111                     {
2112                         set_number(expected_value + l, res_desc->Type, input_value + l, D3DXPT_FLOAT);
2113                     }
2114                 }
2115                 ok(hr == D3D_OK, "%u - %s: SetVector failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2116             }
2117             else
2118             {
2119                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetVector failed, got %#x, expected %#x\n",
2120                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2121             }
2122             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2123             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2124
2125             /* SetVectorArray */
2126             for (element = 0; element < res_desc->Elements + 1; ++element)
2127             {
2128                 fvalue = 1.33;
2129                 for (l = 0; l < element * 4; ++l)
2130                 {
2131                     *(input_value + l) = *(DWORD *)&fvalue;
2132                     fvalue += 1.12;
2133                 }
2134                 memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2135                 hr = effect->lpVtbl->SetVectorArray(effect, parameter, (D3DXVECTOR4 *)input_value, element);
2136                 if (res_desc->Elements && res_desc->Class == D3DXPC_VECTOR && element <= res_desc->Elements)
2137                 {
2138                     for (m = 0; m < element; ++m)
2139                     {
2140                         for (l = 0; l < res_desc->Columns; ++l)
2141                         {
2142                             set_number(expected_value + m * res_desc->Columns + l, res_desc->Type, input_value + m * 4 + l, D3DXPT_FLOAT);
2143                         }
2144                     }
2145                     ok(hr == D3D_OK, "%u - %s: SetVectorArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2146                 }
2147                 else
2148                 {
2149                     ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetVectorArray failed, got %#x, expected %#x\n",
2150                             i, res_full_name, hr, D3DERR_INVALIDCALL);
2151                 }
2152                 test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2153                 test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2154             }
2155
2156             /* SetMatrix */
2157             fvalue = 1.33;
2158             for (l = 0; l < 16; ++l)
2159             {
2160                 *(input_value + l) = *(DWORD *)&fvalue;
2161                 fvalue += 1.12;
2162             }
2163             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2164             hr = effect->lpVtbl->SetMatrix(effect, parameter, (D3DXMATRIX *)input_value);
2165             if (!res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
2166             {
2167                 for (l = 0; l < 4; ++l)
2168                 {
2169                     for (m = 0; m < 4; ++m)
2170                     {
2171                         if (m < res_desc->Rows && l < res_desc->Columns)
2172                             set_number(expected_value + l + m * res_desc->Columns, res_desc->Type,
2173                                     input_value + l + m * 4, D3DXPT_FLOAT);
2174                     }
2175
2176                 }
2177                 ok(hr == D3D_OK, "%u - %s: SetMatrix failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2178             }
2179             else
2180             {
2181                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrix failed, got %#x, expected %#x\n",
2182                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2183             }
2184             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2185             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2186
2187             /* SetMatrixArray */
2188             for (element = 0; element < res_desc->Elements + 1; ++element)
2189             {
2190                 fvalue = 1.33;
2191                 for (l = 0; l < element * 16; ++l)
2192                 {
2193                     *(input_value + l) = *(DWORD *)&fvalue;
2194                     fvalue += 1.12;
2195                 }
2196                 memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2197                 hr = effect->lpVtbl->SetMatrixArray(effect, parameter, (D3DXMATRIX *)input_value, element);
2198                 if (res_desc->Class == D3DXPC_MATRIX_ROWS && element <= res_desc->Elements)
2199                 {
2200                     for (n = 0; n < element; ++n)
2201                     {
2202                         for (l = 0; l < 4; ++l)
2203                         {
2204                             for (m = 0; m < 4; ++m)
2205                             {
2206                                 if (m < res_desc->Rows && l < res_desc->Columns)
2207                                     set_number(expected_value + l + m * res_desc->Columns + n * res_desc->Columns * res_desc->Rows,
2208                                             res_desc->Type, input_value + l + m * 4 + n * 16, D3DXPT_FLOAT);
2209                             }
2210
2211                         }
2212                     }
2213                     ok(hr == D3D_OK, "%u - %s: SetMatrixArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2214                 }
2215                 else
2216                 {
2217                     ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixArray failed, got %#x, expected %#x\n",
2218                             i, res_full_name, hr, D3DERR_INVALIDCALL);
2219                 }
2220                 test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2221                 test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2222             }
2223
2224             /* SetMatrixPointerArray */
2225             for (element = 0; element < res_desc->Elements + 1; ++element)
2226             {
2227                 fvalue = 1.33;
2228                 for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
2229                 {
2230                     *(input_value + l) = *(DWORD *)&fvalue;
2231                     fvalue += 1.12;
2232                 }
2233                 memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2234                 for (l = 0; l < element; ++l)
2235                 {
2236                     matrix_pointer_array[l] = (D3DXMATRIX *)&input_value[l * sizeof(**matrix_pointer_array) / sizeof(FLOAT)];
2237                 }
2238                 hr = effect->lpVtbl->SetMatrixPointerArray(effect, parameter, matrix_pointer_array, element);
2239                 if (res_desc->Class == D3DXPC_MATRIX_ROWS && res_desc->Elements >= element)
2240                 {
2241                     for (n = 0; n < element; ++n)
2242                     {
2243                         for (l = 0; l < 4; ++l)
2244                         {
2245                             for (m = 0; m < 4; ++m)
2246                             {
2247                                 if (m < res_desc->Rows && l < res_desc->Columns)
2248                                     set_number(expected_value + l + m * res_desc->Columns + n * res_desc->Columns * res_desc->Rows,
2249                                             res_desc->Type, input_value + l + m * 4 + n * 16, D3DXPT_FLOAT);
2250                             }
2251
2252                         }
2253                     }
2254                     ok(hr == D3D_OK, "%u - %s: SetMatrixPointerArray failed, got %#x, expected %#x\n",
2255                             i, res_full_name, hr, D3D_OK);
2256                 }
2257                 else
2258                 {
2259                     ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixPointerArray failed, got %#x, expected %#x\n",
2260                             i, res_full_name, hr, D3DERR_INVALIDCALL);
2261                 }
2262                 test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2263                 test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2264             }
2265
2266             /* SetMatrixTranspose */
2267             fvalue = 1.33;
2268             for (l = 0; l < 16; ++l)
2269             {
2270                 *(input_value + l) = *(DWORD *)&fvalue;
2271                 fvalue += 1.12;
2272             }
2273             memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2274             hr = effect->lpVtbl->SetMatrixTranspose(effect, parameter, (D3DXMATRIX *)input_value);
2275             if (!res_desc->Elements && res_desc->Class == D3DXPC_MATRIX_ROWS)
2276             {
2277                 for (l = 0; l < 4; ++l)
2278                 {
2279                     for (m = 0; m < 4; ++m)
2280                     {
2281                         if (m < res_desc->Rows && l < res_desc->Columns)
2282                             set_number(expected_value + l + m * res_desc->Columns, res_desc->Type,
2283                                     input_value + l * 4 + m, D3DXPT_FLOAT);
2284                     }
2285
2286                 }
2287                 ok(hr == D3D_OK, "%u - %s: SetMatrixTranspose failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2288             }
2289             else
2290             {
2291                 ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTranspose failed, got %#x, expected %#x\n",
2292                         i, res_full_name, hr, D3DERR_INVALIDCALL);
2293             }
2294             test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2295             test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2296
2297             /* SetMatrixTransposeArray */
2298             for (element = 0; element < res_desc->Elements + 1; ++element)
2299             {
2300                 fvalue = 1.33;
2301                 for (l = 0; l < element * 16; ++l)
2302                 {
2303                     *(input_value + l) = *(DWORD *)&fvalue;
2304                     fvalue += 1.12;
2305                 }
2306                 memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2307                 hr = effect->lpVtbl->SetMatrixTransposeArray(effect, parameter, (D3DXMATRIX *)input_value, element);
2308                 if (res_desc->Class == D3DXPC_MATRIX_ROWS && element <= res_desc->Elements)
2309                 {
2310                     for (n = 0; n < element; ++n)
2311                     {
2312                         for (l = 0; l < 4; ++l)
2313                         {
2314                             for (m = 0; m < 4; ++m)
2315                             {
2316                                 if (m < res_desc->Rows && l < res_desc->Columns)
2317                                     set_number(expected_value + l + m * res_desc->Columns + n * res_desc->Columns * res_desc->Rows,
2318                                             res_desc->Type, input_value + l * 4 + m + n * 16, D3DXPT_FLOAT);
2319                             }
2320
2321                         }
2322                     }
2323                     ok(hr == D3D_OK, "%u - %s: SetMatrixTransposeArray failed, got %#x, expected %#x\n", i, res_full_name, hr, D3D_OK);
2324                 }
2325                 else
2326                 {
2327                     ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTransposeArray failed, got %#x, expected %#x\n",
2328                             i, res_full_name, hr, D3DERR_INVALIDCALL);
2329                 }
2330                 test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2331                 test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2332             }
2333
2334             /* SetMatrixTransposePointerArray */
2335             for (element = 0; element < res_desc->Elements + 1; ++element)
2336             {
2337                 fvalue = 1.33;
2338                 for (l = 0; l < EFFECT_PARAMETER_VALUE_ARRAY_SIZE; ++l)
2339                 {
2340                     *(input_value + l) = *(DWORD *)&fvalue;
2341                     fvalue += 1.12;
2342                 }
2343                 memcpy(expected_value, &blob[res_value_offset], res_desc->Bytes);
2344                 for (l = 0; l < element; ++l)
2345                 {
2346                     matrix_pointer_array[l] = (D3DXMATRIX *)&input_value[l * sizeof(**matrix_pointer_array) / sizeof(FLOAT)];
2347                 }
2348                 hr = effect->lpVtbl->SetMatrixTransposePointerArray(effect, parameter, matrix_pointer_array, element);
2349                 if (res_desc->Class == D3DXPC_MATRIX_ROWS && res_desc->Elements >= element)
2350                 {
2351                     for (n = 0; n < element; ++n)
2352                     {
2353                         for (l = 0; l < 4; ++l)
2354                         {
2355                             for (m = 0; m < 4; ++m)
2356                             {
2357                                 if (m < res_desc->Rows && l < res_desc->Columns)
2358                                     set_number(expected_value + l + m * res_desc->Columns + n * res_desc->Columns * res_desc->Rows,
2359                                             res_desc->Type, input_value + l * 4 + m + n * 16, D3DXPT_FLOAT);
2360                             }
2361
2362                         }
2363                     }
2364                     ok(hr == D3D_OK, "%u - %s: SetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
2365                             i, res_full_name, hr, D3D_OK);
2366                 }
2367                 else
2368                 {
2369                     ok(hr == D3DERR_INVALIDCALL, "%u - %s: SetMatrixTransposePointerArray failed, got %#x, expected %#x\n",
2370                             i, res_full_name, hr, D3DERR_INVALIDCALL);
2371                 }
2372                 test_effect_parameter_value_GetTestGroup(&res[k], effect, expected_value, parameter, i);
2373                 test_effect_parameter_value_ResetValue(&res[k], effect, &blob[res_value_offset], parameter, i);
2374             }
2375         }
2376
2377         count = effect->lpVtbl->Release(effect);
2378         ok(!count, "Release failed %u\n", count);
2379     }
2380 }
2381
2382 START_TEST(effect)
2383 {
2384     HWND wnd;
2385     IDirect3D9 *d3d;
2386     IDirect3DDevice9 *device;
2387     D3DPRESENT_PARAMETERS d3dpp;
2388     HRESULT hr;
2389     ULONG count;
2390
2391     wnd = CreateWindow("static", "d3dx9_test", 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
2392     d3d = Direct3DCreate9(D3D_SDK_VERSION);
2393     if (!wnd) {
2394         skip("Couldn't create application window\n");
2395         return;
2396     }
2397     if (!d3d) {
2398         skip("Couldn't create IDirect3D9 object\n");
2399         DestroyWindow(wnd);
2400         return;
2401     }
2402
2403     ZeroMemory(&d3dpp, sizeof(d3dpp));
2404     d3dpp.Windowed = TRUE;
2405     d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
2406     hr = IDirect3D9_CreateDevice(d3d, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, wnd, D3DCREATE_MIXED_VERTEXPROCESSING, &d3dpp, &device);
2407     if (FAILED(hr)) {
2408         skip("Failed to create IDirect3DDevice9 object %#x\n", hr);
2409         IDirect3D9_Release(d3d);
2410         DestroyWindow(wnd);
2411         return;
2412     }
2413
2414     test_create_effect_and_pool(device);
2415     test_create_effect_compiler();
2416     test_effect_parameter_value(device);
2417
2418     count = IDirect3DDevice9_Release(device);
2419     ok(count == 0, "The device was not properly freed: refcount %u\n", count);
2420
2421     count = IDirect3D9_Release(d3d);
2422     ok(count == 0, "Release failed %u\n", count);
2423
2424     DestroyWindow(wnd);
2425 }