[PATCH v3 8/9] d3dx9: Implement recording parameters to parameter block.

[Paul Gofman]

Signed-off-by: Paul Gofman 
---
    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(&param->members[i], &vector[i]);
+                    set_vector(&param->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(&param->members[i], &matrix[i]);
+                    set_matrix(&param->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(&param->members[i], matrix[i]);
+                    set_matrix(&param->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(&param->members[i], &matrix[i]);
+                    set_matrix_transpose(&param->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(&param->members[i], matrix[i]);
+                    set_matrix_transpose(&param->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);