Signed-off-by: Paul Gofman <gofmanp(a)gmail.com>
---
v2 (basically redid the whole thing):
- get rid of separate set_dirty() calls;
- do not update parameter data while recording blocks;
- record string parameters update as well.
v3:
- fix refcounting logic in _SetTexture(): current texture in param->data
is irrelevant when settign texture to parameter block.
dlls/d3dx9_36/effect.c | 242 +++++++++++++++++++++++++----------
dlls/d3dx9_36/tests/effect.c | 38 ++++--
2 files changed, 205 insertions(+), 75 deletions(-)
diff --git a/dlls/d3dx9_36/effect.c b/dlls/d3dx9_36/effect.c
index d5b2c35937..7aba622e58 100644
--- a/dlls/d3dx9_36/effect.c
+++ b/dlls/d3dx9_36/effect.c
@@ -36,6 +36,7 @@ static const char parameter_block_magic_string[4] = {'@', '!', '#', '\xFE'};
#define PARAMETER_FLAG_SHARED 1
#define INITIAL_POOL_SIZE 16
+#define INITIAL_PARAM_BLOCK_SIZE 1024
WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
@@ -153,6 +154,15 @@ struct d3dx_parameter_block
{
char magic_string[ARRAY_SIZE(parameter_block_magic_string)];
struct list entry;
+ size_t buffer_size;
+ size_t current_size;
+ BYTE *buffer;
+};
+
+struct d3dx_recorded_parameter
+{
+ struct d3dx_parameter *param;
+ unsigned int bytes;
};
struct d3dx_effect
@@ -704,11 +714,27 @@ static void free_technique(struct d3dx_technique *technique)
technique->name = NULL;
}
+static unsigned int get_recorded_parameter_size(const struct d3dx_recorded_parameter *record)
+{
+ return sizeof(*record) + record->bytes;
+}
+
static void free_parameter_block(struct d3dx_parameter_block *block)
{
+ struct d3dx_recorded_parameter *record;
+
if (!block)
return;
+ record = (struct d3dx_recorded_parameter *)block->buffer;
+ while ((BYTE *)record < block->buffer + block->current_size)
+ {
+ free_parameter_object_data(record->param, record + 1, record->bytes);
+ record = (struct d3dx_recorded_parameter *)((BYTE *)record + get_recorded_parameter_size(record));
+ }
+ assert((BYTE *)record == block->buffer + block->current_size);
+
+ heap_free(block->buffer);
heap_free(block);
}
@@ -776,14 +802,12 @@ static void get_vector(struct d3dx_parameter *param, D3DXVECTOR4 *vector)
}
}
-static void set_vector(struct d3dx_parameter *param, const D3DXVECTOR4 *vector)
+static void set_vector(struct d3dx_parameter *param, const D3DXVECTOR4 *vector, void *dst_data)
{
UINT i;
for (i = 0; i < param->columns; ++i)
- {
- set_number((FLOAT *)param->data + i, param->type, (FLOAT *)vector + i, D3DXPT_FLOAT);
- }
+ set_number((FLOAT *)dst_data + i, param->type, (FLOAT *)vector + i, D3DXPT_FLOAT);
}
static void get_matrix(struct d3dx_parameter *param, D3DXMATRIX *matrix, BOOL transpose)
@@ -804,31 +828,33 @@ static void get_matrix(struct d3dx_parameter *param, D3DXMATRIX *matrix, BOOL tr
}
}
-static void set_matrix(struct d3dx_parameter *param, const D3DXMATRIX *matrix)
+static void set_matrix(struct d3dx_parameter *param, const D3DXMATRIX *matrix, void *dst_data)
{
UINT i, k;
if (param->type == D3DXPT_FLOAT)
{
if (param->columns == 4)
- memcpy(param->data, matrix->u.m, param->rows * 4 * sizeof(float));
+ {
+ memcpy(dst_data, matrix->u.m, param->rows * 4 * sizeof(float));
+ }
else
+ {
for (i = 0; i < param->rows; ++i)
- memcpy((float *)param->data + i * param->columns, matrix->u.m + i, param->columns * sizeof(float));
+ memcpy((float *)dst_data + i * param->columns, matrix->u.m + i, param->columns * sizeof(float));
+ }
return;
}
for (i = 0; i < param->rows; ++i)
{
for (k = 0; k < param->columns; ++k)
- {
- set_number((FLOAT *)param->data + i * param->columns + k, param->type,
+ set_number((FLOAT *)dst_data + i * param->columns + k, param->type,
&matrix->u.m[i][k], D3DXPT_FLOAT);
- }
}
}
-static void set_matrix_transpose(struct d3dx_parameter *param, const D3DXMATRIX *matrix)
+static void set_matrix_transpose(struct d3dx_parameter *param, const D3DXMATRIX *matrix, void *dst_data)
{
UINT i, k;
@@ -836,7 +862,7 @@ static void set_matrix_transpose(struct d3dx_parameter *param, const D3DXMATRIX
{
for (k = 0; k < param->columns; ++k)
{
- set_number((FLOAT *)param->data + i * param->columns + k, param->type,
+ set_number((FLOAT *)dst_data + i * param->columns + k, param->type,
&matrix->u.m[k][i], D3DXPT_FLOAT);
}
}
@@ -855,7 +881,8 @@ static HRESULT set_string(char **param_data, const char *string)
return D3D_OK;
}
-static HRESULT set_value(struct d3dx_parameter *param, const void *data, unsigned int bytes)
+static HRESULT set_value(struct d3dx_parameter *param, const void *data, unsigned int bytes,
+ void *dst_data)
{
unsigned int i, count;
@@ -871,7 +898,7 @@ static HRESULT set_value(struct d3dx_parameter *param, const void *data, unsigne
case D3DXPT_TEXTURECUBE:
for (i = 0; i < count; ++i)
{
- IUnknown *old_texture = ((IUnknown **)param->data)[i];
+ IUnknown *old_texture = ((IUnknown **)dst_data)[i];
IUnknown *new_texture = ((IUnknown **)data)[i];
if (new_texture == old_texture)
@@ -888,7 +915,7 @@ static HRESULT set_value(struct d3dx_parameter *param, const void *data, unsigne
case D3DXPT_INT:
case D3DXPT_FLOAT:
TRACE("Copy %u bytes.\n", bytes);
- memcpy(param->data, data, bytes);
+ memcpy(dst_data, data, bytes);
break;
case D3DXPT_STRING:
@@ -896,7 +923,7 @@ static HRESULT set_value(struct d3dx_parameter *param, const void *data, unsigne
HRESULT hr;
for (i = 0; i < count; ++i)
- if (FAILED(hr = set_string(&((char **)param->data)[i], ((const char **)data)[i])))
+ if (FAILED(hr = set_string(&((char **)dst_data)[i], ((const char **)data)[i])))
return hr;
break;
}
@@ -1246,6 +1273,43 @@ static ULONG64 next_effect_update_version(struct d3dx_effect *effect)
return next_update_version(get_version_counter_ptr(effect));
}
+static void *record_parameter(struct d3dx_effect *effect, struct d3dx_parameter *param, unsigned int bytes)
+{
+ struct d3dx_parameter_block *block = effect->current_parameter_block;
+ struct d3dx_recorded_parameter new_record, *record;
+ unsigned int new_size, alloc_size;
+
+ new_record.param = param;
+ new_record.bytes = bytes;
+ new_size = block->current_size + get_recorded_parameter_size(&new_record);
+
+ if (new_size > block->buffer_size)
+ {
+ BYTE *new_alloc;
+
+ alloc_size = max(block->buffer_size * 2, max(new_size, INITIAL_PARAM_BLOCK_SIZE));
+ if (block->buffer_size)
+ new_alloc = heap_realloc(block->buffer, alloc_size);
+ else
+ new_alloc = heap_alloc(alloc_size);
+
+ if (!new_alloc)
+ {
+ ERR("Out of memory.\n");
+ return param->data;
+ }
+ /* Data update functions may want to free some references upon setting value. */
+ memset(new_alloc + block->buffer_size, 0, alloc_size - block->buffer_size);
+
+ block->buffer_size = alloc_size;
+ block->buffer = new_alloc;
+ }
+ record = (struct d3dx_recorded_parameter *)(block->buffer + block->current_size);
+ *record = new_record;
+ block->current_size = new_size;
+ return record + 1;
+}
+
static void set_dirty(struct d3dx_parameter *param)
{
struct d3dx_shared_data *shared_data;
@@ -1258,6 +1322,17 @@ static void set_dirty(struct d3dx_parameter *param)
top_param->update_version = new_update_version;
}
+static void *parameter_get_update_data(struct d3dx_effect *effect, struct d3dx_parameter *param,
+ unsigned int bytes, BOOL value_changed)
+{
+ assert(bytes <= param->bytes);
+
+ if (value_changed && !effect->current_parameter_block)
+ set_dirty(param);
+
+ return effect->current_parameter_block ? record_parameter(effect, param, bytes) : param->data;
+}
+
static void d3dx9_set_light_parameter(enum LIGHT_TYPE op, D3DLIGHT9 *light, void *value)
{
static const struct
@@ -2362,10 +2437,7 @@ static HRESULT WINAPI d3dx_effect_SetValue(ID3DXEffect *iface, D3DXHANDLE parame
}
if (data && param->bytes <= bytes)
- {
- set_dirty(param);
- return set_value(param, data, bytes);
- }
+ return set_value(param, data, bytes, parameter_get_update_data(effect, param, param->bytes, TRUE));
WARN("Invalid argument specified.\n");
@@ -2446,8 +2518,8 @@ static HRESULT WINAPI d3dx_effect_SetBool(ID3DXEffect *iface, D3DXHANDLE paramet
if (param && !param->element_count && param->rows == 1 && param->columns == 1)
{
- set_number(param->data, param->type, &b, D3DXPT_BOOL);
- set_dirty(param);
+ set_number(parameter_get_update_data(effect, param, sizeof(int), TRUE),
+ param->type, &b, D3DXPT_BOOL);
return D3D_OK;
}
@@ -2479,6 +2551,7 @@ static HRESULT WINAPI d3dx_effect_SetBoolArray(ID3DXEffect *iface, D3DXHANDLE pa
{
struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
+ void *data;
TRACE("iface %p, parameter %p, b %p, count %u.\n", iface, parameter, b, count);
@@ -2493,12 +2566,12 @@ static HRESULT WINAPI d3dx_effect_SetBoolArray(ID3DXEffect *iface, D3DXHANDLE pa
case D3DXPC_SCALAR:
case D3DXPC_VECTOR:
case D3DXPC_MATRIX_ROWS:
+ data = parameter_get_update_data(effect, param, size * sizeof(int), TRUE);
for (i = 0; i < size; ++i)
{
/* don't crop the input, use D3DXPT_INT instead of D3DXPT_BOOL */
- set_number((DWORD *)param->data + i, param->type, &b[i], D3DXPT_INT);
+ set_number((DWORD *)data + i, param->type, &b[i], D3DXPT_INT);
}
- set_dirty(param);
return D3D_OK;
case D3DXPC_OBJECT:
@@ -2556,9 +2629,8 @@ static HRESULT WINAPI d3dx_effect_SetInt(ID3DXEffect *iface, D3DXHANDLE paramete
DWORD value;
set_number(&value, param->type, &n, D3DXPT_INT);
- if (value != *(DWORD *)param->data)
- set_dirty(param);
- *(DWORD *)param->data = value;
+ *(DWORD *)parameter_get_update_data(effect, param, sizeof(int),
+ value != *(DWORD *)param->data) = value;
return D3D_OK;
}
@@ -2567,14 +2639,19 @@ static HRESULT WINAPI d3dx_effect_SetInt(ID3DXEffect *iface, D3DXHANDLE paramete
&& ((param->class == D3DXPC_VECTOR && param->columns != 2)
|| (param->class == D3DXPC_MATRIX_ROWS && param->rows != 2 && param->columns == 1)))
{
+ void *data;
+
TRACE("Vector fixup.\n");
- *(float *)param->data = ((n & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE;
- ((float *)param->data)[1] = ((n & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE;
- ((float *)param->data)[2] = (n & 0xff) * INT_FLOAT_MULTI_INVERSE;
+ data = parameter_get_update_data(effect, param,
+ min(4, param->rows * param->columns) * sizeof(float), TRUE);
+
+ *(float *)data = ((n & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE;
+ ((float *)data)[1] = ((n & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE;
+ ((float *)data)[2] = (n & 0xff) * INT_FLOAT_MULTI_INVERSE;
if (param->rows * param->columns > 3)
- ((float *)param->data)[3] = ((n & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
- set_dirty(param);
+ ((float *)data)[3] = ((n & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
+
return D3D_OK;
}
}
@@ -2626,6 +2703,7 @@ static HRESULT WINAPI d3dx_effect_SetIntArray(ID3DXEffect *iface, D3DXHANDLE par
{
struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
+ void *data;
TRACE("iface %p, parameter %p, n %p, count %u.\n", iface, parameter, n, count);
@@ -2640,9 +2718,9 @@ static HRESULT WINAPI d3dx_effect_SetIntArray(ID3DXEffect *iface, D3DXHANDLE par
case D3DXPC_SCALAR:
case D3DXPC_VECTOR:
case D3DXPC_MATRIX_ROWS:
+ data = parameter_get_update_data(effect, param, size * sizeof(int), TRUE);
for (i = 0; i < size; ++i)
- set_number((DWORD *)param->data + i, param->type, &n[i], D3DXPT_INT);
- set_dirty(param);
+ set_number((DWORD *)data + i, param->type, &n[i], D3DXPT_INT);
return D3D_OK;
case D3DXPC_OBJECT:
@@ -2696,9 +2774,8 @@ static HRESULT WINAPI d3dx_effect_SetFloat(ID3DXEffect *iface, D3DXHANDLE parame
DWORD value;
set_number(&value, param->type, &f, D3DXPT_FLOAT);
- if (value != *(DWORD *)param->data)
- set_dirty(param);
- *(DWORD *)param->data = value;
+ *(DWORD *)parameter_get_update_data(effect, param, sizeof(float),
+ value != *(DWORD *)param->data) = value;
return D3D_OK;
}
@@ -2731,6 +2808,7 @@ static HRESULT WINAPI d3dx_effect_SetFloatArray(ID3DXEffect *iface, D3DXHANDLE p
{
struct d3dx_effect *effect = impl_from_ID3DXEffect(iface);
struct d3dx_parameter *param = get_valid_parameter(effect, parameter);
+ void *data;
TRACE("iface %p, parameter %p, f %p, count %u.\n", iface, parameter, f, count);
@@ -2745,9 +2823,9 @@ static HRESULT WINAPI d3dx_effect_SetFloatArray(ID3DXEffect *iface, D3DXHANDLE p
case D3DXPC_SCALAR:
case D3DXPC_VECTOR:
case D3DXPC_MATRIX_ROWS:
+ data = parameter_get_update_data(effect, param, size * sizeof(float), TRUE);
for (i = 0; i < size; ++i)
- set_number((DWORD *)param->data + i, param->type, &f[i], D3DXPT_FLOAT);
- set_dirty(param);
+ set_number((DWORD *)data + i, param->type, &f[i], D3DXPT_FLOAT);
return D3D_OK;
case D3DXPC_OBJECT:
@@ -2804,7 +2882,6 @@ static HRESULT WINAPI d3dx_effect_SetVector(ID3DXEffect *iface, D3DXHANDLE param
{
case D3DXPC_SCALAR:
case D3DXPC_VECTOR:
- set_dirty(param);
if (param->type == D3DXPT_INT && param->bytes == 4)
{
DWORD tmp;
@@ -2815,16 +2892,17 @@ static HRESULT WINAPI d3dx_effect_SetVector(ID3DXEffect *iface, D3DXHANDLE param
tmp += ((DWORD)(max(min(vector->x, 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 16;
tmp += ((DWORD)(max(min(vector->w, 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 24;
- *(int *)param->data = tmp;
+ *(int *)parameter_get_update_data(effect, param, sizeof(int), TRUE) = tmp;
return D3D_OK;
}
if (param->type == D3DXPT_FLOAT)
{
- memcpy(param->data, vector, param->columns * sizeof(float));
+ memcpy(parameter_get_update_data(effect, param, param->columns * sizeof(float), TRUE),
+ vector, param->columns * sizeof(float));
return D3D_OK;
}
- set_vector(param, vector);
+ set_vector(param, vector, parameter_get_update_data(effect, param, param->columns * sizeof(float), TRUE));
return D3D_OK;
case D3DXPC_MATRIX_ROWS:
@@ -2897,26 +2975,34 @@ static HRESULT WINAPI d3dx_effect_SetVectorArray(ID3DXEffect *iface, D3DXHANDLE
if (param && param->element_count && param->element_count >= count)
{
unsigned int i;
+ BYTE *data;
TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
switch (param->class)
{
case D3DXPC_VECTOR:
- set_dirty(param);
+ data = (BYTE *)parameter_get_update_data(effect, param,
+ count * param->columns * sizeof(float), TRUE);
+
if (param->type == D3DXPT_FLOAT)
{
if (param->columns == 4)
- memcpy(param->data, vector, count * 4 * sizeof(float));
+ {
+ memcpy(data, vector, count * 4 * sizeof(float));
+ }
else
+ {
for (i = 0; i < count; ++i)
- memcpy((float *)param->data + param->columns * i, vector + i,
+ memcpy((float *)data + param->columns * i, vector + i,
param->columns * sizeof(float));
+ }
return D3D_OK;
}
for (i = 0; i < count; ++i)
- set_vector(¶m->members[i], &vector[i]);
+ set_vector(¶m->members[i], &vector[i], data + i * param->columns * sizeof(float));
+
return D3D_OK;
case D3DXPC_SCALAR:
@@ -2991,8 +3077,8 @@ static HRESULT WINAPI d3dx_effect_SetMatrix(ID3DXEffect *iface, D3DXHANDLE param
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
- set_matrix(param, matrix);
- set_dirty(param);
+ set_matrix(param, matrix, parameter_get_update_data(effect, param,
+ param->rows * param->columns * sizeof(float), TRUE));
return D3D_OK;
case D3DXPC_SCALAR:
@@ -3057,15 +3143,20 @@ static HRESULT WINAPI d3dx_effect_SetMatrixArray(ID3DXEffect *iface, D3DXHANDLE
if (param && param->element_count >= count)
{
unsigned int i;
+ BYTE *data;
TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
- set_dirty(param);
+ data = parameter_get_update_data(effect, param, count * param->rows
+ * param->columns * sizeof(float), TRUE);
+
for (i = 0; i < count; ++i)
- set_matrix(¶m->members[i], &matrix[i]);
+ set_matrix(¶m->members[i], &matrix[i],
+ data + i * param->rows * param->columns * sizeof(float));
+
return D3D_OK;
case D3DXPC_SCALAR:
@@ -3137,13 +3228,18 @@ static HRESULT WINAPI d3dx_effect_SetMatrixPointerArray(ID3DXEffect *iface, D3DX
if (param && count <= param->element_count)
{
unsigned int i;
+ BYTE *data;
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
- set_dirty(param);
+ data = parameter_get_update_data(effect, param, count * param->rows
+ * param->columns * sizeof(float), TRUE);
+
for (i = 0; i < count; ++i)
- set_matrix(¶m->members[i], matrix[i]);
+ set_matrix(¶m->members[i], matrix[i], data + i * param->rows
+ * param->columns * sizeof(float));
+
return D3D_OK;
case D3DXPC_SCALAR:
@@ -3217,8 +3313,8 @@ static HRESULT WINAPI d3dx_effect_SetMatrixTranspose(ID3DXEffect *iface, D3DXHAN
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
- set_dirty(param);
- set_matrix_transpose(param, matrix);
+ set_matrix_transpose(param, matrix, parameter_get_update_data(effect, param,
+ param->rows * param->columns * sizeof(float), TRUE));
return D3D_OK;
case D3DXPC_SCALAR:
@@ -3287,15 +3383,20 @@ static HRESULT WINAPI d3dx_effect_SetMatrixTransposeArray(ID3DXEffect *iface, D3
if (param && param->element_count >= count)
{
unsigned int i;
+ BYTE *data;
TRACE("Class %s.\n", debug_d3dxparameter_class(param->class));
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
- set_dirty(param);
+ data = parameter_get_update_data(effect, param, count * param->rows
+ * param->columns * sizeof(float), TRUE);
+
for (i = 0; i < count; ++i)
- set_matrix_transpose(¶m->members[i], &matrix[i]);
+ set_matrix_transpose(¶m->members[i], &matrix[i], data
+ + i * param->rows * param->columns * sizeof(float));
+
return D3D_OK;
case D3DXPC_SCALAR:
@@ -3367,13 +3468,18 @@ static HRESULT WINAPI d3dx_effect_SetMatrixTransposePointerArray(ID3DXEffect *if
if (param && count <= param->element_count)
{
unsigned int i;
+ BYTE *data;
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
- set_dirty(param);
+ data = parameter_get_update_data(effect, param, count * param->rows
+ * param->columns * sizeof(float), TRUE);
+
for (i = 0; i < count; ++i)
- set_matrix_transpose(¶m->members[i], matrix[i]);
+ set_matrix_transpose(¶m->members[i], matrix[i], data
+ + i * param->rows * param->columns * sizeof(float));
+
return D3D_OK;
case D3DXPC_SCALAR:
@@ -3440,10 +3546,7 @@ static HRESULT WINAPI d3dx_effect_SetString(ID3DXEffect *iface, D3DXHANDLE param
TRACE("iface %p, parameter %p, string %s.\n", iface, parameter, debugstr_a(string));
if (param && param->type == D3DXPT_STRING)
- {
- set_dirty(param);
- return set_string(param->data, string);
- }
+ return set_string(parameter_get_update_data(effect, param, sizeof(void *), TRUE), string);
WARN("Parameter not found.\n");
@@ -3482,7 +3585,11 @@ static HRESULT WINAPI d3dx_effect_SetTexture(ID3DXEffect *iface, D3DXHANDLE para
|| param->type == D3DXPT_TEXTURE2D || param->type == D3DXPT_TEXTURE3D
|| param->type == D3DXPT_TEXTURECUBE))
{
- IDirect3DBaseTexture9 *old_texture = *(IDirect3DBaseTexture9 **)param->data;
+ IDirect3DBaseTexture9 **data = parameter_get_update_data(effect, param,
+ sizeof(void *), texture != *(IDirect3DBaseTexture9 **)param->data);
+ IDirect3DBaseTexture9 *old_texture = *data;
+
+ *data = texture;
if (texture == old_texture)
return D3D_OK;
@@ -3492,9 +3599,6 @@ static HRESULT WINAPI d3dx_effect_SetTexture(ID3DXEffect *iface, D3DXHANDLE para
if (old_texture)
IDirect3DBaseTexture9_Release(old_texture);
- *(IDirect3DBaseTexture9 **)param->data = texture;
- set_dirty(param);
-
return D3D_OK;
}
@@ -4135,6 +4239,10 @@ static D3DXHANDLE WINAPI d3dx_effect_EndParameterBlock(ID3DXEffect *iface)
return NULL;
}
ret = effect->current_parameter_block;
+
+ ret->buffer = heap_realloc(ret->buffer, ret->current_size);
+ ret->buffer_size = ret->current_size;
+
effect->current_parameter_block = NULL;
list_add_tail(&effect->parameter_block_list, &ret->entry);
return (D3DXHANDLE)ret;
diff --git a/dlls/d3dx9_36/tests/effect.c b/dlls/d3dx9_36/tests/effect.c
index 86cad3e0cf..d86ae2acb5 100644
--- a/dlls/d3dx9_36/tests/effect.c
+++ b/dlls/d3dx9_36/tests/effect.c
@@ -8019,13 +8019,13 @@ static void test_effect_parameter_block(void)
static const float float_array_zero[4];
IDirect3DTexture9 *texture, *tex_test;
ID3DXEffect *effect, *effect2;
+ D3DXMATRIX mat, mat_arr[2];
D3DXHANDLE block, handle;
IDirect3DDevice9 *device;
ID3DXEffectPool *pool;
float float_array[4];
float float_value;
IDirect3D9 *d3d;
- D3DXMATRIX mat;
ULONG refcount;
HWND window;
HRESULT hr;
@@ -8112,9 +8112,7 @@ static void test_effect_parameter_block(void)
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = effect->lpVtbl->GetTexture(effect, "tex1", (IDirect3DBaseTexture9 **)&tex_test);
- todo_wine ok(hr == D3D_OK && !tex_test, "Got unexpected hr %#x, tex_test %p.\n", hr, tex_test);
- if (tex_test)
- IDirect3DTexture9_Release(tex_test);
+ ok(hr == D3D_OK && !tex_test, "Got unexpected hr %#x, tex_test %p.\n", hr, tex_test);
/* Child parameters and array members are recorded separately (the whole parameter is not
* updated when parameter block is applied).
@@ -8126,13 +8124,13 @@ static void test_effect_parameter_block(void)
hr = effect->lpVtbl->SetFloat(effect, "ts1[0].fv", 28.0f);
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = effect->lpVtbl->GetFloat(effect, "ts1[0].fv", &float_value);
- todo_wine ok(hr == D3D_OK && float_value == 12.0, "Got unexpected hr %#x, float_value %g.\n", hr, float_value);
+ ok(hr == D3D_OK && float_value == 12.0, "Got unexpected hr %#x, float_value %g.\n", hr, float_value);
float_array[0] = -29.0f;
hr = effect->lpVtbl->SetFloatArray(effect, "ts1[0].v2", float_array, 1);
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = effect->lpVtbl->GetFloatArray(effect, "ts1[0].v2", float_array, 1);
- todo_wine ok(hr == D3D_OK && float_array[0] == 13.0, "Got unexpected hr %#x, float_array[0] %g.\n",
+ ok(hr == D3D_OK && float_array[0] == 13.0, "Got unexpected hr %#x, float_array[0] %g.\n",
hr, float_array[0]);
memset(&mat, 0, sizeof(mat));
@@ -8140,13 +8138,13 @@ static void test_effect_parameter_block(void)
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = effect->lpVtbl->GetMatrix(effect, "m3x2row", &mat);
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
- todo_wine ok(!memcmp(&mat, &effect_orig_mat, sizeof(mat)), "Got unexpected matrix.\n");
+ ok(!memcmp(&mat, &effect_orig_mat, sizeof(mat)), "Got unexpected matrix.\n");
hr = effect->lpVtbl->SetMatrix(effect, "m3x2column", &test_mat);
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
hr = effect->lpVtbl->GetMatrix(effect, "m3x2column", &mat);
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
- todo_wine ok(!memcmp(&mat, &effect_orig_mat, sizeof(mat)), "Got unexpected matrix.\n");
+ ok(!memcmp(&mat, &effect_orig_mat, sizeof(mat)), "Got unexpected matrix.\n");
hr = effect2->lpVtbl->SetFloat(effect2, "arr2[1]", -1.0f);
ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
@@ -8238,6 +8236,30 @@ static void test_effect_parameter_block(void)
refcount = pool->lpVtbl->Release(pool);
ok(!refcount, "Got unexpected refcount %u.\n", refcount);
+ hr = D3DXCreateEffect(device, test_effect_parameter_value_blob_float, sizeof(test_effect_parameter_value_blob_float),
+ NULL, NULL, 0, NULL, &effect, NULL);
+ hr = effect->lpVtbl->BeginParameterBlock(effect);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ mat_arr[0] = mat_arr[1] = test_mat;
+ hr = effect->lpVtbl->SetMatrixArray(effect, "f33_2", mat_arr, 2);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ block = effect->lpVtbl->EndParameterBlock(effect);
+ ok(!!block, "Got unexpected block %p.\n", block);
+
+ memset(mat_arr, 0, sizeof(mat_arr));
+ hr = effect->lpVtbl->SetMatrixArray(effect, "f33_2", mat_arr, 2);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ hr = effect->lpVtbl->ApplyParameterBlock(effect, block);
+ todo_wine ok(hr == D3D_OK, "Got result %#x.\n", hr);
+
+ hr = effect->lpVtbl->GetMatrixArray(effect, "f33_2", mat_arr, 2);
+ ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr);
+ todo_wine ok(!memcmp(&mat_arr[0], &test_mat, sizeof(test_mat))
+ && !memcmp(&mat_arr[1], &test_mat, sizeof(test_mat)), "Got unexpected matrix array.\n");
+
+ refcount = effect->lpVtbl->Release(effect);
+ ok(!refcount, "Got unexpected refcount %u.\n", refcount);
+
refcount = IDirect3DDevice9_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
IDirect3D9_Release(d3d);
--
2.23.0
