/*
* Copyright 2010 Christian Costa
- * Copyright 2011 Rico Schأ¼ller
+ * Copyright 2011 Rico Schüller
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
-#include "config.h"
-#include "wine/port.h"
-#define NONAMELESSUNION
-#include "wine/debug.h"
-#include "wine/unicode.h"
-
-#include "windef.h"
-#include "wingdi.h"
#include "d3dx9_36_private.h"
+#include <d3dcompiler.h>
+#include <initguid.h>
+
/* Constants for special INT/FLOAT conversation */
#define INT_FLOAT_MULTI 255.0f
#define INT_FLOAT_MULTI_INVERSE (1/INT_FLOAT_MULTI)
-WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
+static const char parameter_magic_string[4] = {'@', '!', '#', '\xFF'};
+
+#define PARAMETER_FLAG_SHARED 1
+
+#define INITIAL_POOL_SIZE 16
enum STATE_CLASS
{
ST_CONSTANT,
ST_PARAMETER,
ST_FXLC,
+ ST_ARRAY_SELECTOR,
};
-struct d3dx_parameter
+struct d3dx_object
{
- char *name;
- char *semantic;
+ UINT size;
void *data;
- D3DXPARAMETER_CLASS class;
- D3DXPARAMETER_TYPE type;
- UINT rows;
- UINT columns;
- UINT element_count;
- UINT annotation_count;
- UINT member_count;
- DWORD flags;
- UINT bytes;
-
- struct d3dx_parameter *annotations;
- struct d3dx_parameter *members;
+ struct d3dx_parameter *param;
};
struct d3dx_state
UINT operation;
UINT index;
enum STATE_TYPE type;
- struct d3dx_parameter *parameter;
+ struct d3dx_parameter parameter;
+ struct d3dx_parameter *referenced_param;
};
struct d3dx_sampler
struct d3dx_state *states;
struct d3dx_parameter *annotations;
+
+ ULONG64 update_version;
};
struct d3dx_technique
struct d3dx_parameter *annotations;
struct d3dx_pass *passes;
+
+ struct IDirect3DStateBlock9 *saved_state;
};
struct d3dx9_base_effect
UINT parameter_count;
UINT technique_count;
+ UINT object_count;
- struct d3dx_parameter *parameters;
+ struct d3dx_top_level_parameter *parameters;
struct d3dx_technique *techniques;
+ struct d3dx_object *objects;
+
+ struct d3dx_effect_pool *pool;
+ DWORD flags;
+
+ ULONG64 version_counter;
};
struct ID3DXEffectImpl
struct d3dx_technique *active_technique;
struct d3dx_pass *active_pass;
BOOL started;
- DWORD flags;
+ DWORD begin_flags;
+
+ D3DLIGHT9 current_light[8];
+ unsigned int light_updated;
+ D3DMATERIAL9 current_material;
+ BOOL material_updated;
+};
+
+#define INITIAL_SHARED_DATA_SIZE 4
+
+struct d3dx_effect_pool
+{
+ ID3DXEffectPool ID3DXEffectPool_iface;
+ LONG refcount;
+
+ struct d3dx_shared_data *shared_data;
+ unsigned int size;
+
+ ULONG64 version_counter;
};
struct ID3DXEffectCompilerImpl
struct d3dx9_base_effect base_effect;
};
-static struct d3dx_parameter *get_parameter_by_name(struct d3dx9_base_effect *base,
- struct d3dx_parameter *parameter, const char *name);
static struct d3dx_parameter *get_annotation_by_name(UINT count, struct d3dx_parameter *parameters,
const char *name);
-static HRESULT d3dx9_parse_state(struct d3dx_state *state, const char *data, const char **ptr, D3DXHANDLE *objects);
-static void free_parameter_state(struct d3dx_parameter *param, BOOL element, BOOL child, enum STATE_TYPE st);
+static HRESULT d3dx9_parse_state(struct d3dx9_base_effect *base, struct d3dx_state *state,
+ const char *data, const char **ptr, struct d3dx_object *objects);
+static void free_parameter(struct d3dx_parameter *param, BOOL element, BOOL child);
+
+typedef BOOL (*walk_parameter_dep_func)(void *data, struct d3dx_parameter *param);
static const struct
{
}
state_table[] =
{
- /* Render sates */
+ /* Render states */
{SC_RENDERSTATE, D3DRS_ZENABLE, "D3DRS_ZENABLE"}, /* 0x0 */
{SC_RENDERSTATE, D3DRS_FILLMODE, "D3DRS_FILLMODE"},
{SC_RENDERSTATE, D3DRS_SHADEMODE, "D3DRS_SHADEMODE"},
{SC_LIGHT, LT_ATTENUATION2, "LightAttenuation2"},
{SC_LIGHT, LT_THETA, "LightTheta"},
{SC_LIGHT, LT_PHI, "LightPhi"}, /* 0x90 */
- /* Ligthenable */
+ /* Lightenable */
{SC_LIGHTENABLE, 0, "LightEnable"},
/* Vertexshader */
{SC_VERTEXSHADER, 0, "Vertexshader"},
unsigned int i;
DWORD d;
- FIXME("Skipping %u unknown DWORDs:\n", count);
+ WARN("Skipping %u unknown DWORDs:\n", count);
for (i = 0; i < count; ++i)
{
read_dword(ptr, &d);
- FIXME("\t0x%08x\n", d);
+ WARN("\t0x%08x\n", d);
}
}
-static inline struct d3dx_parameter *get_parameter_struct(D3DXHANDLE handle)
-{
- return (struct d3dx_parameter *) handle;
-}
-
static inline D3DXHANDLE get_parameter_handle(struct d3dx_parameter *parameter)
{
- return (D3DXHANDLE) parameter;
+ return (D3DXHANDLE)parameter;
}
static inline D3DXHANDLE get_technique_handle(struct d3dx_technique *technique)
{
- return (D3DXHANDLE) technique;
+ return (D3DXHANDLE)technique;
}
static inline D3DXHANDLE get_pass_handle(struct d3dx_pass *pass)
{
- return (D3DXHANDLE) pass;
+ return (D3DXHANDLE)pass;
}
static struct d3dx_technique *get_technique_by_name(struct d3dx9_base_effect *base, const char *name)
return NULL;
}
-static struct d3dx_parameter *get_valid_sub_parameter(struct d3dx_parameter *param, D3DXHANDLE parameter)
+static struct d3dx_parameter *get_valid_parameter(struct d3dx9_base_effect *base, D3DXHANDLE parameter)
{
- unsigned int i, count;
- struct d3dx_parameter *p;
-
- for (i = 0; i < param->annotation_count; ++i)
- {
- if (get_parameter_handle(¶m->annotations[i]) == parameter)
- return ¶m->annotations[i];
+ struct d3dx_parameter *handle_param = (struct d3dx_parameter *)parameter;
- p = get_valid_sub_parameter(¶m->annotations[i], parameter);
- if (p) return p;
- }
-
- count = param->element_count ? param->element_count : param->member_count;
- for (i = 0; i < count; ++i)
- {
- if (get_parameter_handle(¶m->members[i]) == parameter)
- return ¶m->members[i];
-
- p = get_valid_sub_parameter(¶m->members[i], parameter);
- if (p) return p;
- }
+ if (handle_param && !strncmp(handle_param->magic_string, parameter_magic_string,
+ sizeof(parameter_magic_string)))
+ return handle_param;
- return NULL;
+ return base->flags & D3DXFX_LARGEADDRESSAWARE ? NULL : get_parameter_by_name(base, NULL, parameter);
}
-static struct d3dx_parameter *get_valid_parameter(struct d3dx9_base_effect *base, D3DXHANDLE parameter)
+static void free_state(struct d3dx_state *state)
{
- unsigned int i, k, m;
- struct d3dx_parameter *p;
-
- for (i = 0; i < base->parameter_count; ++i)
- {
- if (get_parameter_handle(&base->parameters[i]) == parameter)
- return &base->parameters[i];
-
- p = get_valid_sub_parameter(&base->parameters[i], parameter);
- if (p) return p;
- }
-
- for (i = 0; i < base->technique_count; ++i)
- {
- struct d3dx_technique *technique = &base->techniques[i];
-
- for (k = 0; k < technique->pass_count; ++k)
- {
- struct d3dx_pass *pass = &technique->passes[k];
-
- for (m = 0; m < pass->annotation_count; ++m)
- {
- if (get_parameter_handle(&pass->annotations[m]) == parameter)
- return &pass->annotations[m];
-
- p = get_valid_sub_parameter(&pass->annotations[m], parameter);
- if (p) return p;
- }
- }
-
- for (k = 0; k < technique->annotation_count; ++k)
- {
- if (get_parameter_handle(&technique->annotations[k]) == parameter)
- return &technique->annotations[k];
-
- p = get_valid_sub_parameter(&technique->annotations[k], parameter);
- if (p) return p;
- }
- }
-
- return get_parameter_by_name(base, NULL, parameter);
+ free_parameter(&state->parameter, FALSE, FALSE);
}
-static void free_state(struct d3dx_state *state)
+static void free_object(struct d3dx_object *object)
{
- free_parameter_state(state->parameter, FALSE, FALSE, state->type);
+ HeapFree(GetProcessHeap(), 0, object->data);
}
static void free_sampler(struct d3dx_sampler *sampler)
HeapFree(GetProcessHeap(), 0, sampler->states);
}
-static void free_parameter(struct d3dx_parameter *param, BOOL element, BOOL child)
-{
- free_parameter_state(param, element, child, ST_CONSTANT);
-}
+static void d3dx_pool_release_shared_parameter(struct d3dx_top_level_parameter *param);
-static void free_parameter_state(struct d3dx_parameter *param, BOOL element, BOOL child, enum STATE_TYPE st)
+static void free_parameter_data(struct d3dx_parameter *param, BOOL child)
{
- unsigned int i;
-
- TRACE("Free parameter %p, name %s, type %s, child %s, state_type %x\n", param, param->name,
- debug_d3dxparameter_type(param->type), child ? "yes" : "no", st);
-
- if (!param)
+ if (!param->data)
return;
-
- if (param->annotations)
- {
- for (i = 0; i < param->annotation_count; ++i)
- free_parameter(¶m->annotations[i], FALSE, FALSE);
- HeapFree(GetProcessHeap(), 0, param->annotations);
- param->annotations = NULL;
- }
-
- if (param->members)
- {
- unsigned int count = param->element_count ? param->element_count : param->member_count;
-
- for (i = 0; i < count; ++i)
- free_parameter(¶m->members[i], param->element_count != 0, TRUE);
- HeapFree(GetProcessHeap(), 0, param->members);
- param->members = NULL;
- }
-
if (param->class == D3DXPC_OBJECT && !param->element_count)
{
switch (param->type)
{
case D3DXPT_STRING:
- HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
- if (!child) HeapFree(GetProcessHeap(), 0, param->data);
+ HeapFree(GetProcessHeap(), 0, *(char **)param->data);
break;
case D3DXPT_TEXTURE:
case D3DXPT_TEXTURECUBE:
case D3DXPT_PIXELSHADER:
case D3DXPT_VERTEXSHADER:
- if (st == ST_CONSTANT)
- {
- if (*(IUnknown **)param->data) IUnknown_Release(*(IUnknown **)param->data);
- }
- else
- {
- HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
- }
- if (!child) HeapFree(GetProcessHeap(), 0, param->data);
+ if (*(IUnknown **)param->data) IUnknown_Release(*(IUnknown **)param->data);
break;
case D3DXPT_SAMPLER:
case D3DXPT_SAMPLER2D:
case D3DXPT_SAMPLER3D:
case D3DXPT_SAMPLERCUBE:
- if (st == ST_CONSTANT)
- {
- free_sampler((struct d3dx_sampler *)param->data);
- }
- else
- {
- HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
- }
- /* samplers have always own data, so free that */
- HeapFree(GetProcessHeap(), 0, param->data);
+ free_sampler((struct d3dx_sampler *)param->data);
break;
default:
break;
}
}
- else
+ if (!child)
+ HeapFree(GetProcessHeap(), 0, param->data);
+}
+
+static void free_parameter(struct d3dx_parameter *param, BOOL element, BOOL child)
+{
+ unsigned int i;
+
+ TRACE("Free parameter %p, name %s, type %s, element %#x, child %#x.\n", param, param->name,
+ debug_d3dxparameter_type(param->type), element, child);
+
+ if (param->param_eval)
+ d3dx_free_param_eval(param->param_eval);
+
+ if (param->members)
{
- if (!child)
- {
- if (st != ST_CONSTANT)
- {
- HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
- }
- HeapFree(GetProcessHeap(), 0, param->data);
- }
+ unsigned int count = param->element_count ? param->element_count : param->member_count;
+
+ for (i = 0; i < count; ++i)
+ free_parameter(¶m->members[i], param->element_count != 0, TRUE);
+ HeapFree(GetProcessHeap(), 0, param->members);
}
+ free_parameter_data(param, child);
+
/* only the parent has to release name and semantic */
if (!element)
{
}
}
+static void free_top_level_parameter(struct d3dx_top_level_parameter *param)
+{
+ if (param->annotations)
+ {
+ unsigned int i;
+
+ for (i = 0; i < param->annotation_count; ++i)
+ free_parameter(¶m->annotations[i], FALSE, FALSE);
+ HeapFree(GetProcessHeap(), 0, param->annotations);
+ }
+ d3dx_pool_release_shared_parameter(param);
+ free_parameter(¶m->param, FALSE, FALSE);
+}
+
static void free_pass(struct d3dx_pass *pass)
{
unsigned int i;
if (!technique)
return;
+ if (technique->saved_state)
+ {
+ IDirect3DStateBlock9_Release(technique->saved_state);
+ technique->saved_state = NULL;
+ }
+
if (technique->annotations)
{
for (i = 0; i < technique->annotation_count; ++i)
if (base->parameters)
{
for (i = 0; i < base->parameter_count; ++i)
- free_parameter(&base->parameters[i], FALSE, FALSE);
+ free_top_level_parameter(&base->parameters[i]);
HeapFree(GetProcessHeap(), 0, base->parameters);
base->parameters = NULL;
}
HeapFree(GetProcessHeap(), 0, base->techniques);
base->techniques = NULL;
}
+
+ if (base->objects)
+ {
+ for (i = 0; i < base->object_count; ++i)
+ {
+ free_object(&base->objects[i]);
+ }
+ HeapFree(GetProcessHeap(), 0, base->objects);
+ base->objects = NULL;
+ }
}
static void free_effect(struct ID3DXEffectImpl *effect)
}
}
-static void set_vector(struct d3dx_parameter *param, CONST D3DXVECTOR4 *vector)
+static void set_vector(struct d3dx_parameter *param, const D3DXVECTOR4 *vector)
{
UINT i;
}
}
-static void set_matrix(struct d3dx_parameter *param, const D3DXMATRIX *matrix, BOOL transpose)
+static void set_matrix(struct d3dx_parameter *param, const D3DXMATRIX *matrix)
+{
+ UINT i, k;
+
+ if (param->type == D3DXPT_FLOAT)
+ {
+ if (param->columns == 4)
+ memcpy(param->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));
+ 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,
+ &matrix->u.m[i][k], D3DXPT_FLOAT);
+ }
+ }
+}
+
+static void set_matrix_transpose(struct d3dx_parameter *param, const D3DXMATRIX *matrix)
{
UINT i, k;
for (k = 0; k < param->columns; ++k)
{
set_number((FLOAT *)param->data + i * param->columns + k, param->type,
- transpose ? &matrix->u.m[k][i] : &matrix->u.m[i][k], D3DXPT_FLOAT);
+ &matrix->u.m[k][i], D3DXPT_FLOAT);
}
}
}
case '.':
return get_parameter_by_name(NULL, temp_parameter, part);
- case '@':
- return get_annotation_by_name(temp_parameter->annotation_count, temp_parameter->annotations, part);
-
case '\0':
TRACE("Returning parameter %p\n", temp_parameter);
return temp_parameter;
return NULL;
}
-static struct d3dx_parameter *get_parameter_by_name(struct d3dx9_base_effect *base,
+struct d3dx_parameter *get_parameter_by_name(struct d3dx9_base_effect *base,
struct d3dx_parameter *parameter, const char *name)
{
UINT i, count, length;
struct d3dx_parameter *temp_parameter;
- struct d3dx_parameter *parameters;
const char *part;
TRACE("base %p, parameter %p, name %s\n", base, parameter, debugstr_a(name));
if (!name || !*name) return NULL;
- if (!parameter)
- {
- count = base->parameter_count;
- parameters = base->parameters;
- }
- else
- {
- count = parameter->member_count;
- parameters = parameter->members;
- }
-
+ count = parameter ? parameter->member_count : base->parameter_count;
length = strcspn( name, "[.@" );
part = name + length;
for (i = 0; i < count; i++)
{
- temp_parameter = ¶meters[i];
+ temp_parameter = !parameter ? &base->parameters[i].param
+ : ¶meter->members[i];
if (!strcmp(temp_parameter->name, name))
{
return get_parameter_by_name(NULL, temp_parameter, part);
case '@':
- return get_annotation_by_name(temp_parameter->annotation_count, temp_parameter->annotations, part);
+ {
+ struct d3dx_top_level_parameter *top_param
+ = top_level_parameter_from_parameter(temp_parameter);
+ return parameter ? NULL : get_annotation_by_name(top_param->annotation_count,
+ top_param->annotations, part);
+ }
case '[':
return get_parameter_element_by_name(temp_parameter, part);
desc->Rows = param->rows;
desc->Columns = param->columns;
desc->Elements = param->element_count;
- desc->Annotations = param->annotation_count;
+ desc->Annotations = is_top_level_parameter(param)
+ ? top_level_parameter_from_parameter(param)->annotation_count : 0;
desc->StructMembers = param->member_count;
desc->Flags = param->flags;
desc->Bytes = param->bytes;
return D3D_OK;
}
+static HRESULT d3dx9_get_param_value_ptr(struct d3dx_pass *pass, struct d3dx_state *state,
+ void **param_value, struct d3dx_parameter **out_param,
+ BOOL update_all, BOOL *param_dirty)
+{
+ struct d3dx_parameter *param = &state->parameter;
+
+ *param_value = NULL;
+ *out_param = NULL;
+ *param_dirty = FALSE;
+
+ switch (state->type)
+ {
+ case ST_PARAMETER:
+ param = state->referenced_param;
+ *param_dirty = is_param_dirty(param, pass->update_version);
+ /* fallthrough */
+ case ST_CONSTANT:
+ *out_param = param;
+ *param_value = param->data;
+ return D3D_OK;
+ case ST_ARRAY_SELECTOR:
+ {
+ unsigned int array_idx;
+ static const struct d3dx_parameter array_idx_param =
+ {"", NULL, NULL, NULL, NULL, D3DXPC_SCALAR, D3DXPT_INT, 1, 1, 0, 0, 0, sizeof(array_idx)};
+ HRESULT hr;
+ struct d3dx_parameter *ref_param, *selected_param;
+
+ if (!param->param_eval)
+ {
+ FIXME("Preshader structure is null.\n");
+ return D3DERR_INVALIDCALL;
+ }
+ /* We override with the update_version of the pass because we want
+ * to force index recomputation and check for out of bounds. */
+ if (is_param_eval_input_dirty(param->param_eval, pass->update_version))
+ {
+ if (FAILED(hr = d3dx_evaluate_parameter(param->param_eval, &array_idx_param, &array_idx)))
+ return hr;
+ }
+ else
+ {
+ array_idx = state->index;
+ }
+ ref_param = state->referenced_param;
+ TRACE("Array index %u, stored array index %u, element_count %u.\n", array_idx, state->index,
+ ref_param->element_count);
+ /* According to the tests, native d3dx handles the case of array index evaluated to -1
+ * in a specific way, always selecting first array element and not returning error. */
+ if (array_idx == ~0u)
+ {
+ WARN("Array index is -1, setting to 0.\n");
+ array_idx = 0;
+ }
+
+ if (array_idx >= ref_param->element_count)
+ {
+ WARN("Computed array index %u is larger than array size %u.\n",
+ array_idx, ref_param->element_count);
+ return E_FAIL;
+ }
+ selected_param = &ref_param->members[array_idx];
+ *param_dirty = state->index != array_idx || is_param_dirty(selected_param, pass->update_version);
+ state->index = array_idx;
+
+ *param_value = selected_param->data;
+ *out_param = selected_param;
+ return D3D_OK;
+ }
+ case ST_FXLC:
+ if (param->param_eval)
+ {
+ *out_param = param;
+ *param_value = param->data;
+ /* We check with the update_version of the pass because the
+ * same preshader might be used by both the vertex and the
+ * pixel shader (that can happen e.g. for sampler states). */
+ if (update_all || is_param_eval_input_dirty(param->param_eval, pass->update_version))
+ {
+ *param_dirty = TRUE;
+ return d3dx_evaluate_parameter(param->param_eval, param, *param_value);
+ }
+ else
+ return D3D_OK;
+ }
+ else
+ {
+ FIXME("No preshader for FXLC parameter.\n");
+ return D3DERR_INVALIDCALL;
+ }
+ }
+ return E_NOTIMPL;
+}
+
static HRESULT d3dx9_base_effect_get_pass_desc(struct d3dx9_base_effect *base,
- D3DXHANDLE pass, D3DXPASS_DESC *desc)
+ D3DXHANDLE pass_handle, D3DXPASS_DESC *desc)
{
- struct d3dx_pass *p = get_valid_pass(base, pass);
+ struct d3dx_pass *pass = get_valid_pass(base, pass_handle);
+ unsigned int i;
- if (!desc || !p)
+ if (!desc || !pass)
{
WARN("Invalid argument specified.\n");
return D3DERR_INVALIDCALL;
}
- desc->Name = p->name;
- desc->Annotations = p->annotation_count;
+ desc->Name = pass->name;
+ desc->Annotations = pass->annotation_count;
- FIXME("Pixel shader and vertex shader are not supported, yet.\n");
desc->pVertexShaderFunction = NULL;
desc->pPixelShaderFunction = NULL;
+ if (base->flags & D3DXFX_NOT_CLONEABLE)
+ return D3D_OK;
+
+ for (i = 0; i < pass->state_count; ++i)
+ {
+ struct d3dx_state *state = &pass->states[i];
+
+ if (state_table[state->operation].class == SC_VERTEXSHADER
+ || state_table[state->operation].class == SC_PIXELSHADER)
+ {
+ struct d3dx_parameter *param;
+ void *param_value;
+ BOOL param_dirty;
+ HRESULT hr;
+
+ if (FAILED(hr = d3dx9_get_param_value_ptr(pass, &pass->states[i], ¶m_value, ¶m,
+ FALSE, ¶m_dirty)))
+ return hr;
+
+ if (!param->object_id)
+ {
+ FIXME("Zero object ID in shader parameter.\n");
+ return E_FAIL;
+ }
+
+ if (state_table[state->operation].class == SC_VERTEXSHADER)
+ desc->pVertexShaderFunction = base->objects[param->object_id].data;
+ else
+ desc->pPixelShaderFunction = base->objects[param->object_id].data;
+ }
+ }
+
return D3D_OK;
}
if (index < base->parameter_count)
{
TRACE("Returning parameter %p.\n", &base->parameters[index]);
- return get_parameter_handle(&base->parameters[index]);
+ return get_parameter_handle(&base->parameters[index].param);
}
}
else
}
}
- WARN("Invalid argument specified.\n");
+ WARN("Parameter not found.\n");
return NULL;
}
{
for (i = 0; i < base->parameter_count; ++i)
{
- temp_param = &base->parameters[i];
+ temp_param = &base->parameters[i].param;
if (!temp_param->semantic)
{
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return NULL;
}
if (index < base->parameter_count)
{
TRACE("Returning parameter %p.\n", &base->parameters[index]);
- return get_parameter_handle(&base->parameters[index]);
+ return get_parameter_handle(&base->parameters[index].param);
}
}
else
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return NULL;
}
return t;
}
- WARN("Invalid argument specified.\n");
+ WARN("Technique not found.\n");
return NULL;
}
return get_pass_handle(&tech->passes[index]);
}
- WARN("Invalid argument specified.\n");
+ WARN("Pass not found.\n");
return NULL;
}
}
}
- WARN("Invalid argument specified.\n");
+ WARN("Pass not found.\n");
return NULL;
}
}
else if (param)
{
- *annotations = param->annotations;
- return param->annotation_count;
+ if (is_top_level_parameter(param))
+ {
+ struct d3dx_top_level_parameter *top_param
+ = top_level_parameter_from_parameter(param);
+
+ *annotations = top_param->annotations;
+ return top_param->annotation_count;
+ }
+ else
+ {
+ *annotations = NULL;
+ return 0;
+ }
}
else
{
return get_parameter_handle(&annotations[index]);
}
- WARN("Invalid argument specified\n");
+ WARN("Annotation not found.\n");
return NULL;
}
return get_parameter_handle(annotation);
}
- WARN("Invalid argument specified\n");
+ WARN("Annotation not found.\n");
return NULL;
}
-static HRESULT d3dx9_base_effect_set_value(struct d3dx9_base_effect *base,
- D3DXHANDLE parameter, const void *data, UINT bytes)
+static BOOL walk_parameter_tree(struct d3dx_parameter *param, walk_parameter_dep_func param_func,
+ void *data)
{
- struct d3dx_parameter *param = get_valid_parameter(base, parameter);
+ unsigned int i;
+ unsigned int member_count;
- if (!param)
- {
- WARN("Invalid parameter %p specified\n", parameter);
- return D3DERR_INVALIDCALL;
- }
+ if (param_func(data, param))
+ return TRUE;
- /* samplers don't touch data */
- if (param->class == D3DXPC_OBJECT && (param->type == D3DXPT_SAMPLER
- || param->type == D3DXPT_SAMPLER1D || param->type == D3DXPT_SAMPLER2D
- || param->type == D3DXPT_SAMPLER3D || param->type == D3DXPT_SAMPLERCUBE))
+ member_count = param->element_count ? param->element_count : param->member_count;
+ for (i = 0; i < member_count; ++i)
{
- TRACE("Sampler: returning E_FAIL\n");
- return E_FAIL;
+ if (walk_parameter_tree(¶m->members[i], param_func, data))
+ return TRUE;
}
+ return FALSE;
+}
- if (data && param->bytes <= bytes)
- {
- switch (param->type)
- {
- case D3DXPT_VOID:
- case D3DXPT_BOOL:
- case D3DXPT_INT:
- case D3DXPT_FLOAT:
- TRACE("Copy %u bytes\n", param->bytes);
- memcpy(param->data, data, param->bytes);
+static ULONG64 *get_version_counter_ptr(struct d3dx9_base_effect *base)
+{
+ return base->pool ? &base->pool->version_counter : &base->version_counter;
+}
+
+static ULONG64 next_effect_update_version(struct d3dx9_base_effect *base)
+{
+ return next_update_version(get_version_counter_ptr(base));
+}
+
+static void set_dirty(struct d3dx_parameter *param)
+{
+ struct d3dx_shared_data *shared_data;
+ struct d3dx_top_level_parameter *top_param = param->top_level_param;
+ ULONG64 new_update_version = next_update_version(top_param->version_counter);
+
+ if ((shared_data = top_param->shared_data))
+ shared_data->update_version = new_update_version;
+ else
+ top_param->update_version = new_update_version;
+}
+
+static HRESULT set_string(char **param_data, const char *string)
+{
+ HeapFree(GetProcessHeap(), 0, *param_data);
+ *param_data = HeapAlloc(GetProcessHeap(), 0, strlen(string) + 1);
+ if (!*param_data)
+ {
+ ERR("Out of memory.\n");
+ return E_OUTOFMEMORY;
+ }
+ strcpy(*param_data, string);
+ return D3D_OK;
+}
+
+static HRESULT d3dx9_base_effect_set_value(struct d3dx9_base_effect *base,
+ D3DXHANDLE parameter, const void *data, UINT bytes)
+{
+ struct d3dx_parameter *param = get_valid_parameter(base, parameter);
+ unsigned int i;
+
+ if (!param)
+ {
+ WARN("Invalid parameter %p specified\n", parameter);
+ return D3DERR_INVALIDCALL;
+ }
+
+ /* samplers don't touch data */
+ if (param->class == D3DXPC_OBJECT && is_param_type_sampler(param->type))
+ {
+ TRACE("Sampler: returning E_FAIL\n");
+ return E_FAIL;
+ }
+
+ if (data && param->bytes <= bytes)
+ {
+ switch (param->type)
+ {
+ case D3DXPT_TEXTURE:
+ case D3DXPT_TEXTURE1D:
+ case D3DXPT_TEXTURE2D:
+ case D3DXPT_TEXTURE3D:
+ case D3DXPT_TEXTURECUBE:
+ for (i = 0; i < (param->element_count ? param->element_count : 1); ++i)
+ {
+ IUnknown *unk = ((IUnknown **)data)[i];
+ if (unk)
+ IUnknown_AddRef(unk);
+
+ unk = ((IUnknown **)param->data)[i];
+ if (unk)
+ IUnknown_Release(unk);
+ }
+ /* fallthrough */
+ case D3DXPT_VOID:
+ case D3DXPT_BOOL:
+ case D3DXPT_INT:
+ case D3DXPT_FLOAT:
+ TRACE("Copy %u bytes.\n", param->bytes);
+ memcpy(param->data, data, param->bytes);
+ set_dirty(param);
+ break;
+
+ case D3DXPT_STRING:
+ {
+ HRESULT hr;
+
+ set_dirty(param);
+ for (i = 0; i < (param->element_count ? param->element_count : 1); ++i)
+ {
+ if (FAILED(hr = set_string(&((char **)param->data)[i], ((const char **)data)[i])))
+ return hr;
+ }
break;
+ }
default:
- FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
+ FIXME("Unhandled type %s.\n", debug_d3dxparameter_type(param->type));
break;
}
}
/* samplers don't touch data */
- if (param->class == D3DXPC_OBJECT && (param->type == D3DXPT_SAMPLER
- || param->type == D3DXPT_SAMPLER1D || param->type == D3DXPT_SAMPLER2D
- || param->type == D3DXPT_SAMPLER3D || param->type == D3DXPT_SAMPLERCUBE))
+ if (param->class == D3DXPC_OBJECT && is_param_type_sampler(param->type))
{
TRACE("Sampler: returning E_FAIL\n");
return E_FAIL;
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
if (param && !param->element_count && param->rows == 1 && param->columns == 1)
{
set_number(param->data, param->type, &b, D3DXPT_BOOL);
+ set_dirty(param);
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
/* 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_dirty(param);
return D3D_OK;
case D3DXPC_OBJECT:
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
{
if (param->rows == 1 && param->columns == 1)
{
- set_number(param->data, param->type, &n, D3DXPT_INT);
+ DWORD value;
+
+ set_number(&value, param->type, &n, D3DXPT_INT);
+ if (value != *(DWORD *)param->data)
+ set_dirty(param);
+ *(DWORD *)param->data = value;
return D3D_OK;
}
{
((FLOAT *)param->data)[3] = ((n & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
}
+ set_dirty(param);
return D3D_OK;
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
{
set_number((DWORD *)param->data + i, param->type, &n[i], D3DXPT_INT);
}
+ set_dirty(param);
return D3D_OK;
case D3DXPC_OBJECT:
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
if (param && !param->element_count && param->rows == 1 && param->columns == 1)
{
- set_number((DWORD *)param->data, param->type, &f, D3DXPT_FLOAT);
+ DWORD value;
+
+ set_number(&value, param->type, &f, D3DXPT_FLOAT);
+ if (value != *(DWORD *)param->data)
+ set_dirty(param);
+ *(DWORD *)param->data = value;
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
{
set_number((DWORD *)param->data + i, param->type, &f[i], D3DXPT_FLOAT);
}
+ set_dirty(param);
return D3D_OK;
case D3DXPC_OBJECT:
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
{
case D3DXPC_SCALAR:
case D3DXPC_VECTOR:
+ set_dirty(param);
if (param->type == D3DXPT_INT && param->bytes == 4)
{
DWORD tmp;
*(INT *)param->data = tmp;
return D3D_OK;
}
+ if (param->type == D3DXPT_FLOAT)
+ {
+ memcpy(param->data, vector, param->columns * sizeof(float));
+ return D3D_OK;
+ }
+
set_vector(param, vector);
return D3D_OK;
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
switch (param->class)
{
case D3DXPC_VECTOR:
+ set_dirty(param);
+ if (param->type == D3DXPT_FLOAT)
+ {
+ if (param->columns == 4)
+ memcpy(param->data, vector, count * 4 * sizeof(float));
+ else
+ for (i = 0; i < count; ++i)
+ memcpy((float *)param->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]);
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
- set_matrix(param, matrix, FALSE);
+ set_matrix(param, matrix);
+ set_dirty(param);
return D3D_OK;
case D3DXPC_SCALAR:
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
+ set_dirty(param);
for (i = 0; i < count; ++i)
{
- set_matrix(¶m->members[i], &matrix[i], FALSE);
+ set_matrix(¶m->members[i], &matrix[i]);
}
return D3D_OK;
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
+ set_dirty(param);
for (i = 0; i < count; ++i)
{
- set_matrix(¶m->members[i], matrix[i], FALSE);
+ set_matrix(¶m->members[i], matrix[i]);
}
return D3D_OK;
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
- set_matrix(param, matrix, TRUE);
+ set_dirty(param);
+ set_matrix_transpose(param, matrix);
return D3D_OK;
case D3DXPC_SCALAR:
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
+ set_dirty(param);
for (i = 0; i < count; ++i)
{
- set_matrix(¶m->members[i], &matrix[i], TRUE);
+ set_matrix_transpose(¶m->members[i], &matrix[i]);
}
return D3D_OK;
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
switch (param->class)
{
case D3DXPC_MATRIX_ROWS:
+ set_dirty(param);
for (i = 0; i < count; ++i)
{
- set_matrix(¶m->members[i], matrix[i], TRUE);
+ set_matrix_transpose(¶m->members[i], matrix[i]);
}
return D3D_OK;
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
}
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
static HRESULT d3dx9_base_effect_set_string(struct d3dx9_base_effect *base,
D3DXHANDLE parameter, const char *string)
{
- FIXME("stub!\n");
+ struct d3dx_parameter *param = get_valid_parameter(base, parameter);
- return E_NOTIMPL;
+ if (param && param->type == D3DXPT_STRING)
+ {
+ set_dirty(param);
+ return set_string(param->data, string);
+ }
+
+ WARN("Parameter not found.\n");
+
+ return D3DERR_INVALIDCALL;
}
static HRESULT d3dx9_base_effect_get_string(struct d3dx9_base_effect *base,
if (string && param && !param->element_count && param->type == D3DXPT_STRING)
{
- *string = *(LPCSTR *)param->data;
- TRACE("Returning %s\n", debugstr_a(*string));
+ *string = *(const char **)param->data;
+ TRACE("Returning %s.\n", debugstr_a(*string));
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
{
struct IDirect3DBaseTexture9 *oltexture = *(struct IDirect3DBaseTexture9 **)param->data;
+ if (texture == oltexture)
+ return D3D_OK;
+
if (texture) IDirect3DBaseTexture9_AddRef(texture);
if (oltexture) IDirect3DBaseTexture9_Release(oltexture);
*(struct IDirect3DBaseTexture9 **)param->data = texture;
+ set_dirty(param);
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
return D3D_OK;
}
- WARN("Invalid argument specified\n");
+ WARN("Parameter not found.\n");
return D3DERR_INVALIDCALL;
}
return E_NOTIMPL;
}
+static void d3dx9_set_light_parameter(enum LIGHT_TYPE op, D3DLIGHT9 *light, void *value)
+{
+ static const struct
+ {
+ unsigned int offset;
+ const char *name;
+ }
+ light_tbl[] =
+ {
+ {FIELD_OFFSET(D3DLIGHT9, Type), "LC_TYPE"},
+ {FIELD_OFFSET(D3DLIGHT9, Diffuse), "LT_DIFFUSE"},
+ {FIELD_OFFSET(D3DLIGHT9, Specular), "LT_SPECULAR"},
+ {FIELD_OFFSET(D3DLIGHT9, Ambient), "LT_AMBIENT"},
+ {FIELD_OFFSET(D3DLIGHT9, Position), "LT_POSITION"},
+ {FIELD_OFFSET(D3DLIGHT9, Direction), "LT_DIRECTION"},
+ {FIELD_OFFSET(D3DLIGHT9, Range), "LT_RANGE"},
+ {FIELD_OFFSET(D3DLIGHT9, Falloff), "LT_FALLOFF"},
+ {FIELD_OFFSET(D3DLIGHT9, Attenuation0), "LT_ATTENUATION0"},
+ {FIELD_OFFSET(D3DLIGHT9, Attenuation1), "LT_ATTENUATION1"},
+ {FIELD_OFFSET(D3DLIGHT9, Attenuation2), "LT_ATTENUATION2"},
+ {FIELD_OFFSET(D3DLIGHT9, Theta), "LT_THETA"},
+ {FIELD_OFFSET(D3DLIGHT9, Phi), "LT_PHI"}
+ };
+ switch (op)
+ {
+ case LT_TYPE:
+ TRACE("LT_TYPE %u.\n", *(D3DLIGHTTYPE *)value);
+ light->Type = *(D3DLIGHTTYPE *)value;
+ break;
+ case LT_DIFFUSE:
+ case LT_SPECULAR:
+ case LT_AMBIENT:
+ {
+ D3DCOLORVALUE c = *(D3DCOLORVALUE *)value;
+
+ TRACE("%s (%.8e %.8e %.8e %.8e).\n", light_tbl[op].name, c.r, c.g, c.b, c.a);
+ *(D3DCOLORVALUE *)((BYTE *)light + light_tbl[op].offset) = c;
+ break;
+ }
+ case LT_POSITION:
+ case LT_DIRECTION:
+ {
+ D3DVECTOR v = *(D3DVECTOR *)value;
+
+ TRACE("%s (%.8e %.8e %.8e).\n", light_tbl[op].name, v.x, v.y, v.z);
+ *(D3DVECTOR *)((BYTE *)light + light_tbl[op].offset) = v;
+ break;
+ }
+ case LT_RANGE:
+ case LT_FALLOFF:
+ case LT_ATTENUATION0:
+ case LT_ATTENUATION1:
+ case LT_ATTENUATION2:
+ case LT_THETA:
+ case LT_PHI:
+ {
+ float v = *(float *)value;
+ TRACE("%s %.8e.\n", light_tbl[op].name, v);
+ *(float *)((BYTE *)light + light_tbl[op].offset) = v;
+ break;
+ }
+ default:
+ WARN("Unknown light parameter %u.\n", op);
+ break;
+ }
+}
+
+static void d3dx9_set_material_parameter(enum MATERIAL_TYPE op, D3DMATERIAL9 *material, void *value)
+{
+ static const struct
+ {
+ unsigned int offset;
+ const char *name;
+ }
+ material_tbl[] =
+ {
+ {FIELD_OFFSET(D3DMATERIAL9, Diffuse), "MT_DIFFUSE"},
+ {FIELD_OFFSET(D3DMATERIAL9, Ambient), "MT_AMBIENT"},
+ {FIELD_OFFSET(D3DMATERIAL9, Specular), "MT_SPECULAR"},
+ {FIELD_OFFSET(D3DMATERIAL9, Emissive), "MT_EMISSIVE"},
+ {FIELD_OFFSET(D3DMATERIAL9, Power), "MT_POWER"}
+ };
+
+ switch (op)
+ {
+ case MT_POWER:
+ {
+ float v = *(float *)value;
+
+ TRACE("%s %.8e.\n", material_tbl[op].name, v);
+ material->Power = v;
+ break;
+ }
+ case MT_DIFFUSE:
+ case MT_AMBIENT:
+ case MT_SPECULAR:
+ case MT_EMISSIVE:
+ {
+ D3DCOLORVALUE c = *(D3DCOLORVALUE *)value;
+
+ TRACE("%s, value (%.8e %.8e %.8e %.8e).\n", material_tbl[op].name, c.r, c.g, c.b, c.a);
+ *(D3DCOLORVALUE *)((BYTE *)material + material_tbl[op].offset) = c;
+ break;
+ }
+ default:
+ WARN("Unknown material parameter %u.\n", op);
+ break;
+ }
+}
+
+static HRESULT d3dx_set_shader_const_state(struct ID3DXEffectImpl *effect, enum SHADER_CONSTANT_TYPE op, UINT index,
+ struct d3dx_parameter *param, void *value_ptr)
+{
+ static const struct
+ {
+ D3DXPARAMETER_TYPE type;
+ UINT elem_size;
+ const char *name;
+ }
+ const_tbl[] =
+ {
+ {D3DXPT_FLOAT, sizeof(float) * 4, "SCT_VSFLOAT"},
+ {D3DXPT_BOOL, sizeof(BOOL), "SCT_VSBOOL"},
+ {D3DXPT_INT, sizeof(int) * 4, "SCT_VSINT"},
+ {D3DXPT_FLOAT, sizeof(float) * 4, "SCT_PSFLOAT"},
+ {D3DXPT_BOOL, sizeof(BOOL), "SCT_PSBOOL"},
+ {D3DXPT_INT, sizeof(int) * 4, "SCT_PSINT"},
+ };
+ unsigned int element_count;
+
+ if (op < 0 || op > SCT_PSINT)
+ {
+ FIXME("Unknown op %u.\n", op);
+ return D3DERR_INVALIDCALL;
+ }
+ element_count = param->bytes / const_tbl[op].elem_size;
+ TRACE("%s, index %u, element_count %u.\n", const_tbl[op].name, index, element_count);
+ if (param->type != const_tbl[op].type)
+ {
+ FIXME("Unexpected param type %u.\n", param->type);
+ return D3DERR_INVALIDCALL;
+ }
+ if (param->bytes % const_tbl[op].elem_size != 0)
+ {
+ FIXME("Unexpected param size %u, rows %u, cols %u.\n", param->bytes, param->rows, param->columns);
+ return D3DERR_INVALIDCALL;
+ }
+
+ switch (op)
+ {
+ case SCT_VSFLOAT:
+ return SET_D3D_STATE(effect, SetVertexShaderConstantF, index, (const float *)value_ptr, element_count);
+ case SCT_VSBOOL:
+ return SET_D3D_STATE(effect, SetVertexShaderConstantB, index, (const BOOL *)value_ptr, element_count);
+ case SCT_VSINT:
+ return SET_D3D_STATE(effect, SetVertexShaderConstantI, index, (const int *)value_ptr, element_count);
+ case SCT_PSFLOAT:
+ return SET_D3D_STATE(effect, SetPixelShaderConstantF, index, (const float *)value_ptr, element_count);
+ case SCT_PSBOOL:
+ return SET_D3D_STATE(effect, SetPixelShaderConstantB, index, (const BOOL *)value_ptr, element_count);
+ case SCT_PSINT:
+ return SET_D3D_STATE(effect, SetPixelShaderConstantI, index, (const int *)value_ptr, element_count);
+ }
+ return D3D_OK;
+}
+
+static HRESULT d3dx9_apply_state(struct ID3DXEffectImpl *effect, struct d3dx_pass *pass,
+ struct d3dx_state *state, unsigned int parent_index, BOOL update_all);
+
+static HRESULT d3dx_set_shader_constants(struct ID3DXEffectImpl *effect, struct d3dx_pass *pass,
+ struct d3dx_parameter *param, BOOL vs, BOOL update_all)
+{
+ HRESULT hr, ret;
+ struct d3dx_parameter **params;
+ D3DXCONSTANT_DESC *cdesc;
+ unsigned int parameters_count;
+ unsigned int i, j;
+
+ if (!param->param_eval)
+ {
+ FIXME("param_eval structure is null.\n");
+ return D3DERR_INVALIDCALL;
+ }
+ if (FAILED(hr = d3dx_param_eval_set_shader_constants(effect->manager, effect->device,
+ param->param_eval, update_all)))
+ return hr;
+ params = param->param_eval->shader_inputs.inputs_param;
+ cdesc = param->param_eval->shader_inputs.inputs;
+ parameters_count = param->param_eval->shader_inputs.input_count;
+ ret = D3D_OK;
+ for (i = 0; i < parameters_count; ++i)
+ {
+ if (params[i] && params[i]->class == D3DXPC_OBJECT && is_param_type_sampler(params[i]->type))
+ {
+ struct d3dx_sampler *sampler;
+ unsigned int sampler_idx;
+
+ for (sampler_idx = 0; sampler_idx < cdesc[i].RegisterCount; ++sampler_idx)
+ {
+ sampler = params[i]->element_count ? params[i]->members[sampler_idx].data : params[i]->data;
+ TRACE("sampler %s, register index %u, state count %u.\n", debugstr_a(params[i]->name),
+ cdesc[i].RegisterIndex, sampler->state_count);
+ for (j = 0; j < sampler->state_count; ++j)
+ {
+ if (FAILED(hr = d3dx9_apply_state(effect, pass, &sampler->states[j],
+ cdesc[i].RegisterIndex + sampler_idx + (vs ? D3DVERTEXTEXTURESAMPLER0 : 0),
+ update_all)))
+ ret = hr;
+ }
+ }
+ }
+ }
+ return ret;
+}
+
+static HRESULT d3dx9_apply_state(struct ID3DXEffectImpl *effect, struct d3dx_pass *pass,
+ struct d3dx_state *state, unsigned int parent_index, BOOL update_all)
+{
+ struct d3dx_parameter *param;
+ void *param_value;
+ BOOL param_dirty;
+ HRESULT hr;
+
+ TRACE("operation %u, index %u, type %u.\n", state->operation, state->index, state->type);
+
+ if (FAILED(hr = d3dx9_get_param_value_ptr(pass, state, ¶m_value, ¶m,
+ update_all, ¶m_dirty)))
+ {
+ if (!update_all && hr == E_FAIL)
+ {
+ /* Native d3dx9 returns D3D_OK from CommitChanges() involving
+ * out of bounds array access and does not touch the affected
+ * states. */
+ WARN("Returning D3D_OK on out of bounds array access.\n");
+ return D3D_OK;
+ }
+ return hr;
+ }
+
+ if (!(update_all || param_dirty
+ || state_table[state->operation].class == SC_VERTEXSHADER
+ || state_table[state->operation].class == SC_PIXELSHADER
+ || state_table[state->operation].class == SC_SETSAMPLER))
+ return D3D_OK;
+
+ switch (state_table[state->operation].class)
+ {
+ case SC_RENDERSTATE:
+ TRACE("%s, operation %u, value %u.\n", state_table[state->operation].name,
+ state_table[state->operation].op, *(DWORD *)param_value);
+ return SET_D3D_STATE(effect, SetRenderState, state_table[state->operation].op, *(DWORD *)param_value);
+ case SC_FVF:
+ TRACE("%s, value %#x.\n", state_table[state->operation].name, *(DWORD *)param_value);
+ return SET_D3D_STATE(effect, SetFVF, *(DWORD *)param_value);
+ case SC_TEXTURE:
+ {
+ UINT unit;
+
+ unit = parent_index == ~0u ? state->index : parent_index;
+ TRACE("%s, unit %u, value %p.\n", state_table[state->operation].name, unit,
+ *(IDirect3DBaseTexture9 **)param_value);
+ return SET_D3D_STATE(effect, SetTexture, unit, *(IDirect3DBaseTexture9 **)param_value);
+ }
+ case SC_TEXTURESTAGE:
+ TRACE("%s, stage %u, value %u.\n", state_table[state->operation].name, state->index, *(DWORD *)param_value);
+ return SET_D3D_STATE(effect, SetTextureStageState, state->index,
+ state_table[state->operation].op, *(DWORD *)param_value);
+ case SC_SETSAMPLER:
+ {
+ struct d3dx_sampler *sampler;
+ HRESULT ret, hr;
+ unsigned int i;
+
+ sampler = (struct d3dx_sampler *)param_value;
+ TRACE("%s, sampler %u, applying %u states.\n", state_table[state->operation].name, state->index,
+ sampler->state_count);
+ ret = D3D_OK;
+ for (i = 0; i < sampler->state_count; i++)
+ {
+ if (FAILED(hr = d3dx9_apply_state(effect, pass, &sampler->states[i], state->index, update_all)))
+ ret = hr;
+ }
+ return ret;
+ }
+ case SC_SAMPLERSTATE:
+ {
+ UINT sampler;
+
+ sampler = parent_index == ~0u ? state->index : parent_index;
+ TRACE("%s, sampler %u, value %u.\n", state_table[state->operation].name, sampler, *(DWORD *)param_value);
+ return SET_D3D_STATE(effect, SetSamplerState, sampler, state_table[state->operation].op,
+ *(DWORD *)param_value);
+ }
+ case SC_VERTEXSHADER:
+ TRACE("%s, shader %p.\n", state_table[state->operation].name, *(IDirect3DVertexShader9 **)param_value);
+ if ((update_all || param_dirty)
+ && FAILED(hr = SET_D3D_STATE(effect, SetVertexShader,
+ *(IDirect3DVertexShader9 **)param_value)))
+ ERR("Could not set vertex shader, hr %#x.\n", hr);
+ else if (*(IDirect3DVertexShader9 **)param_value)
+ hr = d3dx_set_shader_constants(effect, pass, param, TRUE, update_all || param_dirty);
+ return hr;
+ case SC_PIXELSHADER:
+ TRACE("%s, shader %p.\n", state_table[state->operation].name, *(IDirect3DPixelShader9 **)param_value);
+ if ((update_all || param_dirty)
+ && FAILED(hr = SET_D3D_STATE(effect, SetPixelShader,
+ *(IDirect3DPixelShader9 **)param_value)))
+ ERR("Could not set pixel shader, hr %#x.\n", hr);
+ else if (*(IDirect3DPixelShader9 **)param_value)
+ hr = d3dx_set_shader_constants(effect, pass, param, FALSE, update_all || param_dirty);
+ return hr;
+ case SC_TRANSFORM:
+ TRACE("%s, state %u.\n", state_table[state->operation].name, state->index);
+ return SET_D3D_STATE(effect, SetTransform, state_table[state->operation].op + state->index,
+ (D3DMATRIX *)param_value);
+ case SC_LIGHTENABLE:
+ TRACE("%s, index %u, value %u.\n", state_table[state->operation].name, state->index, *(BOOL *)param_value);
+ return SET_D3D_STATE(effect, LightEnable, state->index, *(BOOL *)param_value);
+ case SC_LIGHT:
+ {
+ TRACE("%s, index %u, op %u.\n", state_table[state->operation].name, state->index,
+ state_table[state->operation].op);
+ d3dx9_set_light_parameter(state_table[state->operation].op,
+ &effect->current_light[state->index], param_value);
+ effect->light_updated |= 1u << state->index;
+ return D3D_OK;
+ }
+ case SC_MATERIAL:
+ {
+ TRACE("%s, index %u, op %u.\n", state_table[state->operation].name, state->index,
+ state_table[state->operation].op);
+ d3dx9_set_material_parameter(state_table[state->operation].op,
+ &effect->current_material, param_value);
+ effect->material_updated = TRUE;
+ return D3D_OK;
+ }
+ case SC_NPATCHMODE:
+ TRACE("%s, nsegments %f.\n", state_table[state->operation].name, *(float *)param_value);
+ return SET_D3D_STATE(effect, SetNPatchMode, *(float *)param_value);
+ case SC_SHADERCONST:
+ TRACE("%s, index %u, op %u.\n", state_table[state->operation].name, state->index,
+ state_table[state->operation].op);
+ return d3dx_set_shader_const_state(effect, state_table[state->operation].op, state->index,
+ param, param_value);
+ default:
+ FIXME("%s not handled.\n", state_table[state->operation].name);
+ break;
+ }
+ return D3D_OK;
+}
+
+static HRESULT d3dx9_apply_pass_states(struct ID3DXEffectImpl *effect, struct d3dx_pass *pass, BOOL update_all)
+{
+ unsigned int i;
+ HRESULT ret;
+ HRESULT hr;
+ ULONG64 new_update_version = next_effect_update_version(&effect->base_effect);
+
+ TRACE("effect %p, pass %p, state_count %u.\n", effect, pass, pass->state_count);
+
+ ret = D3D_OK;
+ for (i = 0; i < pass->state_count; ++i)
+ {
+ if (FAILED(hr = d3dx9_apply_state(effect, pass, &pass->states[i], ~0u, update_all)))
+ {
+ WARN("Error applying state, hr %#x.\n", hr);
+ ret = hr;
+ }
+ }
+
+ if (effect->light_updated)
+ {
+ for (i = 0; i < ARRAY_SIZE(effect->current_light); ++i)
+ {
+ if ((effect->light_updated & (1u << i))
+ && FAILED(hr = SET_D3D_STATE(effect, SetLight, i, &effect->current_light[i])))
+ {
+ WARN("Error setting light, hr %#x.\n", hr);
+ ret = hr;
+ }
+ }
+ effect->light_updated = 0;
+ }
+
+ if (effect->material_updated
+ && FAILED(hr = SET_D3D_STATE(effect, SetMaterial, &effect->current_material)))
+ {
+ WARN("Error setting material, hr %#x.\n", hr);
+ ret = hr;
+ }
+ effect->material_updated = FALSE;
+
+ pass->update_version = new_update_version;
+ return ret;
+}
+
+static void param_set_data_pointer(struct d3dx_parameter *param, unsigned char *data, BOOL child, BOOL free_data)
+{
+ unsigned char *member_data = data;
+ unsigned int i, count;
+
+ count = param->element_count ? param->element_count : param->member_count;
+ for (i = 0; i < count; ++i)
+ {
+ param_set_data_pointer(¶m->members[i], member_data, TRUE, free_data);
+ if (data)
+ member_data += param->members[i].bytes;
+ }
+ if (free_data)
+ free_parameter_data(param, child);
+ param->data = data;
+}
+
+static BOOL is_same_parameter(void *param1_, struct d3dx_parameter *param2)
+{
+ struct d3dx_parameter *param1 = (struct d3dx_parameter *)param1_;
+ BOOL matches;
+ unsigned int i, member_count;
+
+ matches = !strcmp(param1->name, param2->name) && param1->class == param2->class
+ && param1->type == param2->type && param1->rows == param2->rows
+ && param1->columns == param2->columns && param1->element_count == param2->element_count
+ && param1->member_count == param2->member_count;
+
+ member_count = param1->element_count ? param1->element_count : param1->member_count;
+
+ if (!matches || !member_count)
+ return matches;
+
+ for (i = 0; i < member_count; ++i)
+ {
+ if (!is_same_parameter(¶m1->members[i], ¶m2->members[i]))
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static HRESULT d3dx_pool_sync_shared_parameter(struct d3dx_effect_pool *pool, struct d3dx_top_level_parameter *param)
+{
+ unsigned int i, free_entry_index;
+ unsigned int new_size, new_count;
+
+ if (!(param->param.flags & PARAMETER_FLAG_SHARED) || !pool || is_param_type_sampler(param->param.type))
+ return D3D_OK;
+
+ free_entry_index = pool->size;
+ for (i = 0; i < pool->size; ++i)
+ {
+ if (!pool->shared_data[i].count)
+ free_entry_index = i;
+ else if (is_same_parameter(¶m->param, &pool->shared_data[i].parameters[0]->param))
+ break;
+ }
+ if (i == pool->size)
+ {
+ i = free_entry_index;
+ if (i == pool->size)
+ {
+ struct d3dx_shared_data *new_alloc;
+
+ if (!pool->size)
+ {
+ new_size = INITIAL_POOL_SIZE;
+ new_alloc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+ sizeof(*pool->shared_data) * new_size);
+ if (!new_alloc)
+ {
+ ERR("Out of memory.\n");
+ return E_OUTOFMEMORY;
+ }
+ }
+ else
+ {
+ new_size = pool->size * 2;
+ new_alloc = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pool->shared_data,
+ sizeof(*pool->shared_data) * new_size);
+ if (!new_alloc)
+ {
+ ERR("Out of memory.\n");
+ return E_OUTOFMEMORY;
+ }
+ if (new_alloc != pool->shared_data)
+ {
+ unsigned int j, k;
+
+ for (j = 0; j < pool->size; ++j)
+ for (k = 0; k < new_alloc[j].count; ++k)
+ new_alloc[j].parameters[k]->shared_data = &new_alloc[j];
+ }
+ }
+ pool->shared_data = new_alloc;
+ pool->size = new_size;
+ }
+ pool->shared_data[i].data = param->param.data;
+ }
+ else
+ {
+ param_set_data_pointer(¶m->param, pool->shared_data[i].data, FALSE, TRUE);
+ }
+ new_count = ++pool->shared_data[i].count;
+ if (new_count >= pool->shared_data[i].size)
+ {
+ if (!pool->shared_data[i].size)
+ {
+ new_size = INITIAL_SHARED_DATA_SIZE;
+ pool->shared_data[i].parameters = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+ sizeof(*pool->shared_data[i].parameters) * INITIAL_SHARED_DATA_SIZE);
+ }
+ else
+ {
+ new_size = pool->shared_data[i].size * 2;
+ pool->shared_data[i].parameters = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+ pool->shared_data[i].parameters,
+ sizeof(*pool->shared_data[i].parameters) * new_size);
+ }
+ pool->shared_data[i].size = new_size;
+ }
+
+ param->shared_data = &pool->shared_data[i];
+ pool->shared_data[i].parameters[new_count - 1] = param;
+
+ TRACE("name %s, parameter idx %u, new refcount %u.\n", debugstr_a(param->param.name), i,
+ new_count);
+
+ return D3D_OK;
+}
+
+static BOOL param_zero_data_func(void *dummy, struct d3dx_parameter *param)
+{
+ param->data = NULL;
+ return FALSE;
+}
+
+static void d3dx_pool_release_shared_parameter(struct d3dx_top_level_parameter *param)
+{
+ unsigned int new_count;
+
+ if (!(param->param.flags & PARAMETER_FLAG_SHARED) || !param->shared_data)
+ return;
+ new_count = --param->shared_data->count;
+
+ TRACE("param %p, param->shared_data %p, new_count %d.\n", param, param->shared_data, new_count);
+
+ if (new_count)
+ {
+ unsigned int i;
+
+ for (i = 0; i < new_count; ++i)
+ {
+ if (param->shared_data->parameters[i] == param)
+ {
+ memmove(¶m->shared_data->parameters[i],
+ ¶m->shared_data->parameters[i + 1],
+ sizeof(param->shared_data->parameters[i]) * (new_count - i));
+ break;
+ }
+ }
+ walk_parameter_tree(¶m->param, param_zero_data_func, NULL);
+ }
+ else
+ {
+ HeapFree(GetProcessHeap(), 0, param->shared_data->parameters);
+ /* Zeroing table size is required as the entry in pool parameters table can be reused. */
+ param->shared_data->size = 0;
+ param->shared_data = NULL;
+ }
+}
+
+static inline struct d3dx_effect_pool *impl_from_ID3DXEffectPool(ID3DXEffectPool *iface)
+{
+ return CONTAINING_RECORD(iface, struct d3dx_effect_pool, ID3DXEffectPool_iface);
+}
+
static inline struct ID3DXEffectImpl *impl_from_ID3DXEffect(ID3DXEffect *iface)
{
return CONTAINING_RECORD(iface, struct ID3DXEffectImpl, ID3DXEffect_iface);
return D3D_OK;
}
- WARN("Invalid argument supplied.\n");
+ WARN("Technique not found.\n");
return D3DERR_INVALIDCALL;
}
return D3D_OK;
}
-static HRESULT WINAPI ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect* iface, D3DXHANDLE technique, D3DXHANDLE* next_technique)
+static HRESULT WINAPI ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect *iface,
+ D3DXHANDLE technique, D3DXHANDLE *next_technique)
{
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
+ struct d3dx9_base_effect *base_effect = &This->base_effect;
+ UINT i = 0;
- FIXME("(%p)->(%p, %p): stub\n", This, technique, next_technique);
+ TRACE("iface %p, technique %p, next_technique %p\n", iface, technique, next_technique);
- return E_NOTIMPL;
+ if (!next_technique)
+ return D3DERR_INVALIDCALL;
+
+ if (technique)
+ {
+ for (; i < base_effect->technique_count; i++)
+ {
+ if (technique == get_technique_handle(&base_effect->techniques[i]))
+ {
+ i++; /* Go to next technique */
+ break;
+ }
+ }
+ }
+
+ for (; i < base_effect->technique_count; i++)
+ {
+ if (SUCCEEDED(iface->lpVtbl->ValidateTechnique(iface, get_technique_handle(&base_effect->techniques[i]))))
+ {
+ *next_technique = get_technique_handle(&base_effect->techniques[i]);
+ return D3D_OK;
+ }
+ }
+
+ *next_technique = NULL;
+ return S_FALSE;
}
-static BOOL WINAPI ID3DXEffectImpl_IsParameterUsed(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXHANDLE technique)
+static BOOL walk_parameter_dep(struct d3dx_parameter *param, walk_parameter_dep_func param_func,
+ void *data);
+
+static BOOL walk_param_eval_dep(struct d3dx_param_eval *param_eval, walk_parameter_dep_func param_func,
+ void *data)
{
- struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
+ struct d3dx_parameter **params;
+ unsigned int i, param_count;
+
+ if (!param_eval)
+ return FALSE;
+
+ params = param_eval->shader_inputs.inputs_param;
+ param_count = param_eval->shader_inputs.input_count;
+ for (i = 0; i < param_count; ++i)
+ {
+ if (walk_parameter_dep(params[i], param_func, data))
+ return TRUE;
+ }
+
+ params = param_eval->pres.inputs.inputs_param;
+ param_count = param_eval->pres.inputs.input_count;
+ for (i = 0; i < param_count; ++i)
+ {
+ if (walk_parameter_dep(params[i], param_func, data))
+ return TRUE;
+ }
+ return FALSE;
+}
+
+static BOOL walk_state_dep(struct d3dx_state *state, walk_parameter_dep_func param_func,
+ void *data)
+{
+ if (state->type == ST_CONSTANT && is_param_type_sampler(state->parameter.type))
+ {
+ if (walk_parameter_dep(&state->parameter, param_func, data))
+ return TRUE;
+ }
+ else if (state->type == ST_ARRAY_SELECTOR || state->type == ST_PARAMETER)
+ {
+ if (walk_parameter_dep(state->referenced_param, param_func, data))
+ return TRUE;
+ }
+ return walk_param_eval_dep(state->parameter.param_eval, param_func, data);
+}
+
+static BOOL walk_parameter_dep(struct d3dx_parameter *param, walk_parameter_dep_func param_func,
+ void *data)
+{
+ unsigned int i;
+ unsigned int member_count;
+
+ param = ¶m->top_level_param->param;
+ if (param_func(data, param))
+ return TRUE;
+
+ if (walk_param_eval_dep(param->param_eval, param_func, data))
+ return TRUE;
+
+ if (param->class == D3DXPC_OBJECT && is_param_type_sampler(param->type))
+ {
+ struct d3dx_sampler *sampler;
+ unsigned int sampler_idx;
+ unsigned int samplers_count = max(param->element_count, 1);
+
+ for (sampler_idx = 0; sampler_idx < samplers_count; ++sampler_idx)
+ {
+ sampler = param->element_count ? param->members[sampler_idx].data : param->data;
+ for (i = 0; i < sampler->state_count; ++i)
+ {
+ if (walk_state_dep(&sampler->states[i], param_func, data))
+ return TRUE;
+ }
+ }
+ return FALSE;
+ }
+
+ member_count = param->element_count ? param->element_count : param->member_count;
+ for (i = 0; i < member_count; ++i)
+ {
+ if (walk_param_eval_dep(param->members[i].param_eval, param_func, data))
+ return TRUE;
+ }
- FIXME("(%p)->(%p, %p): stub\n", This, parameter, technique);
+ return FALSE;
+}
+static BOOL is_parameter_used(struct d3dx_parameter *param, struct d3dx_technique *tech)
+{
+ unsigned int i, j;
+ struct d3dx_pass *pass;
+
+ if (!tech || !param)
+ return FALSE;
+
+ for (i = 0; i < tech->pass_count; ++i)
+ {
+ pass = &tech->passes[i];
+ for (j = 0; j < pass->state_count; ++j)
+ {
+ if (walk_state_dep(&pass->states[j], is_same_parameter, param))
+ return TRUE;
+ }
+ }
return FALSE;
}
+static BOOL WINAPI ID3DXEffectImpl_IsParameterUsed(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXHANDLE technique)
+{
+ struct ID3DXEffectImpl *effect = impl_from_ID3DXEffect(iface);
+ struct d3dx_parameter *param = get_valid_parameter(&effect->base_effect, parameter);
+ struct d3dx_technique *tech = get_valid_technique(&effect->base_effect, technique);
+ BOOL ret;
+
+ TRACE("iface %p, parameter %p, technique %p.\n", iface, parameter, technique);
+ TRACE("param %p, name %s, tech %p.\n", param, param ? debugstr_a(param->name) : "", tech);
+
+ ret = is_parameter_used(param, tech);
+ TRACE("Returning %#x.\n", ret);
+ return ret;
+}
+
static HRESULT WINAPI ID3DXEffectImpl_Begin(ID3DXEffect *iface, UINT *passes, DWORD flags)
{
- struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
- struct d3dx_technique *technique = This->active_technique;
+ struct ID3DXEffectImpl *effect = impl_from_ID3DXEffect(iface);
+ struct d3dx_technique *technique = effect->active_technique;
- FIXME("iface %p, passes %p, flags %#x partial stub\n", iface, passes, flags);
+ TRACE("iface %p, passes %p, flags %#x.\n", iface, passes, flags);
if (passes && technique)
{
if (flags & ~(D3DXFX_DONOTSAVESTATE | D3DXFX_DONOTSAVESAMPLERSTATE | D3DXFX_DONOTSAVESHADERSTATE))
WARN("Invalid flags (%#x) specified.\n", flags);
- if (This->manager || flags & D3DXFX_DONOTSAVESTATE)
+ if (flags & D3DXFX_DONOTSAVESTATE)
{
TRACE("State capturing disabled.\n");
}
else
{
- FIXME("State capturing not supported, yet!\n");
+ HRESULT hr;
+ unsigned int i;
+
+ if (!technique->saved_state)
+ {
+ ID3DXEffectStateManager *manager;
+
+ manager = effect->manager;
+ effect->manager = NULL;
+ if (FAILED(hr = IDirect3DDevice9_BeginStateBlock(effect->device)))
+ ERR("BeginStateBlock failed, hr %#x.\n", hr);
+ for (i = 0; i < technique->pass_count; i++)
+ d3dx9_apply_pass_states(effect, &technique->passes[i], TRUE);
+ if (FAILED(hr = IDirect3DDevice9_EndStateBlock(effect->device, &technique->saved_state)))
+ ERR("EndStateBlock failed, hr %#x.\n", hr);
+ effect->manager = manager;
+ }
+ if (FAILED(hr = IDirect3DStateBlock9_Capture(technique->saved_state)))
+ ERR("StateBlock Capture failed, hr %#x.\n", hr);
}
*passes = technique->pass_count;
- This->started = TRUE;
- This->flags = flags;
+ effect->started = TRUE;
+ effect->begin_flags = flags;
return D3D_OK;
}
static HRESULT WINAPI ID3DXEffectImpl_BeginPass(ID3DXEffect *iface, UINT pass)
{
- struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
- struct d3dx_technique *technique = This->active_technique;
+ struct ID3DXEffectImpl *effect = impl_from_ID3DXEffect(iface);
+ struct d3dx_technique *technique = effect->active_technique;
- TRACE("iface %p, pass %u\n", This, pass);
+ TRACE("iface %p, pass %u\n", effect, pass);
- if (technique && pass < technique->pass_count && !This->active_pass)
+ if (technique && pass < technique->pass_count && !effect->active_pass)
{
- This->active_pass = &technique->passes[pass];
+ HRESULT hr;
- FIXME("No states applied, yet!\n");
+ memset(effect->current_light, 0, sizeof(effect->current_light));
+ memset(&effect->current_material, 0, sizeof(effect->current_material));
- return D3D_OK;
+ if (SUCCEEDED(hr = d3dx9_apply_pass_states(effect, &technique->passes[pass], TRUE)))
+ effect->active_pass = &technique->passes[pass];
+ return hr;
}
WARN("Invalid argument supplied.\n");
return D3DERR_INVALIDCALL;
}
-static HRESULT WINAPI ID3DXEffectImpl_CommitChanges(ID3DXEffect* iface)
+static HRESULT WINAPI ID3DXEffectImpl_CommitChanges(ID3DXEffect *iface)
{
- struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
+ struct ID3DXEffectImpl *effect = impl_from_ID3DXEffect(iface);
- FIXME("(%p)->(): stub\n", This);
+ TRACE("iface %p.\n", iface);
- return E_NOTIMPL;
+ if (!effect->active_pass)
+ {
+ WARN("Called without an active pass.\n");
+ return D3D_OK;
+ }
+ return d3dx9_apply_pass_states(effect, effect->active_pass, FALSE);
}
static HRESULT WINAPI ID3DXEffectImpl_EndPass(ID3DXEffect *iface)
static HRESULT WINAPI ID3DXEffectImpl_End(ID3DXEffect *iface)
{
- struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
+ struct ID3DXEffectImpl *effect = impl_from_ID3DXEffect(iface);
+ struct d3dx_technique *technique = effect->active_technique;
- FIXME("iface %p partial stub\n", iface);
+ TRACE("iface %p.\n", iface);
- if (!This->started)
+ if (!effect->started)
return D3D_OK;
- if (This->manager || This->flags & D3DXFX_DONOTSAVESTATE)
+ if (effect->begin_flags & D3DXFX_DONOTSAVESTATE)
{
TRACE("State restoring disabled.\n");
}
else
{
- FIXME("State restoring not supported, yet!\n");
+ HRESULT hr;
+
+ if (technique && technique->saved_state)
+ {
+ if (FAILED(hr = IDirect3DStateBlock9_Apply(technique->saved_state)))
+ ERR("State block apply failed, hr %#x.\n", hr);
+ }
+ else
+ ERR("No saved state.\n");
}
- This->started = FALSE;
+ effect->started = FALSE;
return D3D_OK;
}
return E_NOTIMPL;
}
+#if _D3DX9_VER >= 26
static HRESULT WINAPI ID3DXEffectImpl_DeleteParameterBlock(ID3DXEffect* iface, D3DXHANDLE parameter_block)
{
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
return E_NOTIMPL;
}
+#endif
static HRESULT WINAPI ID3DXEffectImpl_CloneEffect(ID3DXEffect *iface,
struct IDirect3DDevice9 *device, struct ID3DXEffect **effect)
FIXME("(%p)->(%p, %p): stub\n", This, device, effect);
- return E_NOTIMPL;
+ if (!effect)
+ return D3DXERR_INVALIDDATA;
+
+ iface->lpVtbl->AddRef(iface);
+ *effect = iface;
+ return S_OK;
}
-static HRESULT WINAPI ID3DXEffectImpl_SetRawValue(ID3DXEffect* iface, D3DXHANDLE parameter, LPCVOID data, UINT byte_offset, UINT bytes)
+#if _D3DX9_VER >= 27
+static HRESULT WINAPI ID3DXEffectImpl_SetRawValue(ID3DXEffect *iface,
+ D3DXHANDLE parameter, const void *data, UINT byte_offset, UINT bytes)
{
- struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
-
- FIXME("(%p)->(%p, %p, %u, %u): stub\n", This, parameter, data, byte_offset, bytes);
+ FIXME("iface %p, parameter %p, data %p, byte_offset %u, bytes %u stub!\n",
+ iface, parameter, data, byte_offset, bytes);
return E_NOTIMPL;
}
+#endif
static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl =
{
ID3DXEffectImpl_BeginParameterBlock,
ID3DXEffectImpl_EndParameterBlock,
ID3DXEffectImpl_ApplyParameterBlock,
+#if _D3DX9_VER >= 26
ID3DXEffectImpl_DeleteParameterBlock,
+#endif
ID3DXEffectImpl_CloneEffect,
+#if _D3DX9_VER >= 27
ID3DXEffectImpl_SetRawValue
+#endif
};
static inline struct ID3DXEffectCompilerImpl *impl_from_ID3DXEffectCompiler(ID3DXEffectCompiler *iface)
ID3DXEffectCompilerImpl_CompileShader,
};
-static HRESULT d3dx9_parse_sampler(struct d3dx_sampler *sampler, const char *data, const char **ptr, D3DXHANDLE *objects)
+static HRESULT d3dx9_parse_sampler(struct d3dx9_base_effect *base, struct d3dx_sampler *sampler,
+ const char *data, const char **ptr, struct d3dx_object *objects)
{
HRESULT hr;
UINT i;
- struct d3dx_state *states;
read_dword(ptr, &sampler->state_count);
TRACE("Count: %u\n", sampler->state_count);
- states = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*states) * sampler->state_count);
- if (!states)
+ sampler->states = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*sampler->states) * sampler->state_count);
+ if (!sampler->states)
{
ERR("Out of memory\n");
return E_OUTOFMEMORY;
for (i = 0; i < sampler->state_count; ++i)
{
- hr = d3dx9_parse_state(&states[i], data, ptr, objects);
+ hr = d3dx9_parse_state(base, &sampler->states[i], data, ptr, objects);
if (hr != D3D_OK)
{
WARN("Failed to parse state %u\n", i);
}
}
- sampler->states = states;
-
return D3D_OK;
err_out:
for (i = 0; i < sampler->state_count; ++i)
{
- free_state(&states[i]);
+ free_state(&sampler->states[i]);
}
-
- HeapFree(GetProcessHeap(), 0, states);
+ HeapFree(GetProcessHeap(), 0, sampler->states);
+ sampler->states = NULL;
return hr;
}
-static HRESULT d3dx9_parse_value(struct d3dx_parameter *param, void *value, const char *data, const char **ptr, D3DXHANDLE *objects)
+static HRESULT d3dx9_parse_value(struct d3dx9_base_effect *base, struct d3dx_parameter *param,
+ void *value, const char *data, const char **ptr, struct d3dx_object *objects)
{
unsigned int i;
HRESULT hr;
UINT old_size = 0;
- DWORD id;
if (param->element_count)
{
{
struct d3dx_parameter *member = ¶m->members[i];
- hr = d3dx9_parse_value(member, value ? (char *)value + old_size : NULL, data, ptr, objects);
+ hr = d3dx9_parse_value(base, member, value ? (char *)value + old_size : NULL, data, ptr, objects);
if (hr != D3D_OK)
{
WARN("Failed to parse value %u\n", i);
{
struct d3dx_parameter *member = ¶m->members[i];
- hr = d3dx9_parse_value(member, (char *)value + old_size, data, ptr, objects);
+ hr = d3dx9_parse_value(base, member, (char *)value + old_size, data, ptr, objects);
if (hr != D3D_OK)
{
WARN("Failed to parse value %u\n", i);
case D3DXPT_TEXTURECUBE:
case D3DXPT_PIXELSHADER:
case D3DXPT_VERTEXSHADER:
- read_dword(ptr, &id);
- TRACE("Id: %u\n", id);
- objects[id] = get_parameter_handle(param);
+ read_dword(ptr, ¶m->object_id);
+ TRACE("Id: %u\n", param->object_id);
+ objects[param->object_id].param = param;
param->data = value;
break;
if (!sampler)
return E_OUTOFMEMORY;
- hr = d3dx9_parse_sampler(sampler, data, ptr, objects);
+ hr = d3dx9_parse_sampler(base, sampler, data, ptr, objects);
if (hr != D3D_OK)
{
HeapFree(GetProcessHeap(), 0, sampler);
return D3D_OK;
}
-static HRESULT d3dx9_parse_init_value(struct d3dx_parameter *param, const char *data, const char *ptr, D3DXHANDLE *objects)
+static HRESULT d3dx9_parse_init_value(struct d3dx9_base_effect *base, struct d3dx_parameter *param,
+ const char *data, const char *ptr, struct d3dx_object *objects)
{
UINT size = param->bytes;
HRESULT hr;
}
}
- hr = d3dx9_parse_value(param, value, data, &ptr, objects);
+ hr = d3dx9_parse_value(base, param, value, data, &ptr, objects);
if (hr != D3D_OK)
{
WARN("Failed to parse value\n");
return D3D_OK;
}
-static HRESULT d3dx9_copy_data(char **str, const char **ptr)
+static HRESULT d3dx9_copy_data(struct d3dx9_base_effect *base, unsigned int object_id, const char **ptr)
{
- DWORD size;
+ struct d3dx_object *object = &base->objects[object_id];
- read_dword(ptr, &size);
- TRACE("Data size: %#x\n", size);
-
- *str = HeapAlloc(GetProcessHeap(), 0, size);
- if (!*str)
+ if (object->size || object->data)
{
- ERR("Failed to allocate name memory.\n");
- return E_OUTOFMEMORY;
- }
-
- TRACE("Data: %s.\n", debugstr_an(*ptr, size));
- memcpy(*str, *ptr, size);
-
- *ptr += ((size + 3) & ~3);
-
- return D3D_OK;
-}
-
-static HRESULT d3dx9_parse_data(struct d3dx_parameter *param, const char **ptr, struct IDirect3DDevice9 *device)
-{
- DWORD size;
- HRESULT hr;
+ if (object_id)
+ FIXME("Overwriting object id %u!\n", object_id);
+ else
+ TRACE("Overwriting object id 0.\n");
- TRACE("Parse data for parameter %s, type %s\n", debugstr_a(param->name), debug_d3dxparameter_type(param->type));
+ HeapFree(GetProcessHeap(), 0, object->data);
+ object->data = NULL;
+ }
- read_dword(ptr, &size);
- TRACE("Data size: %#x\n", size);
+ read_dword(ptr, &object->size);
+ TRACE("Data size: %#x.\n", object->size);
- if (!size)
- {
- TRACE("Size is 0\n");
- *(void **)param->data = NULL;
+ if (!object->size)
return D3D_OK;
- }
- switch (param->type)
+ object->data = HeapAlloc(GetProcessHeap(), 0, object->size);
+ if (!object->data)
{
- case D3DXPT_STRING:
- /* re-read with size (sizeof(DWORD) = 4) */
- hr = d3dx9_parse_name((LPSTR *)param->data, *ptr - 4);
- if (hr != D3D_OK)
- {
- WARN("Failed to parse string data\n");
- return hr;
- }
- break;
-
- case D3DXPT_VERTEXSHADER:
- if (FAILED(hr = IDirect3DDevice9_CreateVertexShader(device, (DWORD *)*ptr, param->data)))
- {
- WARN("Failed to create vertex shader\n");
- return hr;
- }
- break;
-
- case D3DXPT_PIXELSHADER:
- if (FAILED(hr = IDirect3DDevice9_CreatePixelShader(device, (DWORD *)*ptr, param->data)))
- {
- WARN("Failed to create pixel shader\n");
- return hr;
- }
- break;
-
- default:
- FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
- break;
+ ERR("Failed to allocate object memory.\n");
+ return E_OUTOFMEMORY;
}
+ TRACE("Data: %s.\n", debugstr_an(*ptr, object->size));
+ memcpy(object->data, *ptr, object->size);
- *ptr += ((size + 3) & ~3);
+ *ptr += ((object->size + 3) & ~3);
return D3D_OK;
}
-static HRESULT d3dx9_parse_effect_typedef(struct d3dx_parameter *param, const char *data, const char **ptr,
- struct d3dx_parameter *parent, UINT flags)
+static void param_set_magic_number(struct d3dx_parameter *param)
+{
+ memcpy(param->magic_string, parameter_magic_string, sizeof(parameter_magic_string));
+}
+
+static HRESULT d3dx9_parse_effect_typedef(struct d3dx9_base_effect *base, struct d3dx_parameter *param,
+ const char *data, const char **ptr, struct d3dx_parameter *parent, UINT flags)
{
DWORD offset;
HRESULT hr;
if (!parent)
{
- read_dword(ptr, ¶m->type);
+ read_dword(ptr, (DWORD *)¶m->type);
TRACE("Type: %s\n", debug_d3dxparameter_type(param->type));
- read_dword(ptr, ¶m->class);
+ read_dword(ptr, (DWORD *)¶m->class);
TRACE("Class: %s\n", debug_d3dxparameter_class(param->class));
read_dword(ptr, &offset);
param->name = parent->name;
param->semantic = parent->semantic;
param->element_count = 0;
- param->annotation_count = 0;
param->member_count = parent->member_count;
param->bytes = parent->bytes;
param->rows = parent->rows;
{
*ptr = save_ptr;
- hr = d3dx9_parse_effect_typedef(¶m->members[i], data, ptr, param, flags);
+ param_set_magic_number(¶m->members[i]);
+ hr = d3dx9_parse_effect_typedef(base, ¶m->members[i], data, ptr, param, flags);
if (hr != D3D_OK)
{
WARN("Failed to parse member %u\n", i);
for (i = 0; i < param->member_count; ++i)
{
- hr = d3dx9_parse_effect_typedef(¶m->members[i], data, ptr, NULL, flags);
+ param_set_magic_number(¶m->members[i]);
+ hr = d3dx9_parse_effect_typedef(base, ¶m->members[i], data, ptr, NULL, flags);
if (hr != D3D_OK)
{
WARN("Failed to parse member %u\n", i);
return hr;
}
-static HRESULT d3dx9_parse_effect_annotation(struct d3dx_parameter *anno, const char *data, const char **ptr, D3DXHANDLE *objects)
+static HRESULT d3dx9_parse_effect_annotation(struct d3dx9_base_effect *base, struct d3dx_parameter *anno,
+ const char *data, const char **ptr, struct d3dx_object *objects)
{
DWORD offset;
const char *ptr2;
read_dword(ptr, &offset);
TRACE("Typedef offset: %#x\n", offset);
ptr2 = data + offset;
- hr = d3dx9_parse_effect_typedef(anno, data, &ptr2, NULL, D3DX_PARAMETER_ANNOTATION);
+ hr = d3dx9_parse_effect_typedef(base, anno, data, &ptr2, NULL, D3DX_PARAMETER_ANNOTATION);
if (hr != D3D_OK)
{
WARN("Failed to parse type definition\n");
read_dword(ptr, &offset);
TRACE("Value offset: %#x\n", offset);
- hr = d3dx9_parse_init_value(anno, data, data + offset, objects);
+ hr = d3dx9_parse_init_value(base, anno, data, data + offset, objects);
if (hr != D3D_OK)
{
WARN("Failed to parse value\n");
return D3D_OK;
}
-static HRESULT d3dx9_parse_state(struct d3dx_state *state, const char *data, const char **ptr, D3DXHANDLE *objects)
+static HRESULT d3dx9_parse_state(struct d3dx9_base_effect *base, struct d3dx_state *state,
+ const char *data, const char **ptr, struct d3dx_object *objects)
{
DWORD offset;
const char *ptr2;
HRESULT hr;
- struct d3dx_parameter *parameter;
-
- parameter = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*parameter));
- if (!parameter)
- return E_OUTOFMEMORY;
state->type = ST_CONSTANT;
read_dword(ptr, &offset);
TRACE("Typedef offset: %#x\n", offset);
ptr2 = data + offset;
- hr = d3dx9_parse_effect_typedef(parameter, data, &ptr2, NULL, 0);
+ hr = d3dx9_parse_effect_typedef(base, &state->parameter, data, &ptr2, NULL, 0);
if (hr != D3D_OK)
{
WARN("Failed to parse type definition\n");
read_dword(ptr, &offset);
TRACE("Value offset: %#x\n", offset);
- hr = d3dx9_parse_init_value(parameter, data, data + offset, objects);
+ hr = d3dx9_parse_init_value(base, &state->parameter, data, data + offset, objects);
if (hr != D3D_OK)
{
WARN("Failed to parse value\n");
goto err_out;
}
- state->parameter = parameter;
-
return D3D_OK;
err_out:
- free_parameter(parameter, FALSE, FALSE);
+ free_parameter(&state->parameter, FALSE, FALSE);
return hr;
}
-static HRESULT d3dx9_parse_effect_parameter(struct d3dx_parameter *param, const char *data, const char **ptr, D3DXHANDLE *objects)
+static HRESULT d3dx9_parse_effect_parameter(struct d3dx9_base_effect *base, struct d3dx_top_level_parameter *param,
+ const char *data, const char **ptr, struct d3dx_object *objects)
{
DWORD offset;
HRESULT hr;
const char *ptr2;
read_dword(ptr, &offset);
- TRACE("Typedef offset: %#x\n", offset);
+ TRACE("Typedef offset: %#x.\n", offset);
ptr2 = data + offset;
read_dword(ptr, &offset);
- TRACE("Value offset: %#x\n", offset);
+ TRACE("Value offset: %#x.\n", offset);
- read_dword(ptr, ¶m->flags);
- TRACE("Flags: %#x\n", param->flags);
+ read_dword(ptr, ¶m->param.flags);
+ TRACE("Flags: %#x.\n", param->param.flags);
read_dword(ptr, ¶m->annotation_count);
- TRACE("Annotation count: %u\n", param->annotation_count);
+ TRACE("Annotation count: %u.\n", param->annotation_count);
- hr = d3dx9_parse_effect_typedef(param, data, &ptr2, NULL, param->flags);
+ hr = d3dx9_parse_effect_typedef(base, ¶m->param, data, &ptr2, NULL, param->param.flags);
if (hr != D3D_OK)
{
- WARN("Failed to parse type definition\n");
+ WARN("Failed to parse type definition.\n");
return hr;
}
- hr = d3dx9_parse_init_value(param, data, data + offset, objects);
+ hr = d3dx9_parse_init_value(base, ¶m->param, data, data + offset, objects);
if (hr != D3D_OK)
{
- WARN("Failed to parse value\n");
+ WARN("Failed to parse value.\n");
return hr;
}
sizeof(*param->annotations) * param->annotation_count);
if (!param->annotations)
{
- ERR("Out of memory\n");
+ ERR("Out of memory.\n");
hr = E_OUTOFMEMORY;
goto err_out;
}
for (i = 0; i < param->annotation_count; ++i)
{
- hr = d3dx9_parse_effect_annotation(¶m->annotations[i], data, ptr, objects);
+ param_set_magic_number(¶m->annotations[i]);
+ hr = d3dx9_parse_effect_annotation(base, ¶m->annotations[i], data, ptr, objects);
if (hr != D3D_OK)
{
- WARN("Failed to parse annotation\n");
+ WARN("Failed to parse annotation.\n");
goto err_out;
}
}
return hr;
}
-static HRESULT d3dx9_parse_effect_pass(struct d3dx_pass *pass, const char *data, const char **ptr, D3DXHANDLE *objects)
+static HRESULT d3dx9_parse_effect_pass(struct d3dx9_base_effect *base, struct d3dx_pass *pass,
+ const char *data, const char **ptr, struct d3dx_object *objects)
{
DWORD offset;
HRESULT hr;
for (i = 0; i < pass->annotation_count; ++i)
{
- hr = d3dx9_parse_effect_annotation(&pass->annotations[i], data, ptr, objects);
+ param_set_magic_number(&pass->annotations[i]);
+ hr = d3dx9_parse_effect_annotation(base, &pass->annotations[i], data, ptr, objects);
if (hr != D3D_OK)
{
WARN("Failed to parse annotation %u\n", i);
for (i = 0; i < pass->state_count; ++i)
{
- hr = d3dx9_parse_state(&states[i], data, ptr, objects);
+ hr = d3dx9_parse_state(base, &states[i], data, ptr, objects);
if (hr != D3D_OK)
{
WARN("Failed to parse annotation %u\n", i);
return hr;
}
-static HRESULT d3dx9_parse_effect_technique(struct d3dx_technique *technique, const char *data, const char **ptr, D3DXHANDLE *objects)
+static HRESULT d3dx9_parse_effect_technique(struct d3dx9_base_effect *base, struct d3dx_technique *technique,
+ const char *data, const char **ptr, struct d3dx_object *objects)
{
DWORD offset;
HRESULT hr;
for (i = 0; i < technique->annotation_count; ++i)
{
- hr = d3dx9_parse_effect_annotation(&technique->annotations[i], data, ptr, objects);
+ param_set_magic_number(&technique->annotations[i]);
+ hr = d3dx9_parse_effect_annotation(base, &technique->annotations[i], data, ptr, objects);
if (hr != D3D_OK)
{
WARN("Failed to parse annotation %u\n", i);
for (i = 0; i < technique->pass_count; ++i)
{
- hr = d3dx9_parse_effect_pass(&technique->passes[i], data, ptr, objects);
+ hr = d3dx9_parse_effect_pass(base, &technique->passes[i], data, ptr, objects);
if (hr != D3D_OK)
{
WARN("Failed to parse pass %u\n", i);
return hr;
}
-static HRESULT d3dx9_parse_resource(struct d3dx9_base_effect *base, const char *data, const char **ptr)
+static HRESULT d3dx9_create_object(struct d3dx9_base_effect *base, struct d3dx_object *object)
+{
+ struct d3dx_parameter *param = object->param;
+ struct IDirect3DDevice9 *device = base->effect->device;
+ HRESULT hr;
+
+ if (*(char **)param->data)
+ ERR("Parameter data already allocated.\n");
+
+ switch (param->type)
+ {
+ case D3DXPT_STRING:
+ *(char **)param->data = HeapAlloc(GetProcessHeap(), 0, object->size);
+ if (!*(char **)param->data)
+ {
+ ERR("Out of memory.\n");
+ return E_OUTOFMEMORY;
+ }
+ memcpy(*(char **)param->data, object->data, object->size);
+ break;
+ case D3DXPT_VERTEXSHADER:
+ if (FAILED(hr = IDirect3DDevice9_CreateVertexShader(device, object->data,
+ (IDirect3DVertexShader9 **)param->data)))
+ {
+ WARN("Failed to create vertex shader.\n");
+ return D3D_OK;
+ }
+ break;
+ case D3DXPT_PIXELSHADER:
+ if (FAILED(hr = IDirect3DDevice9_CreatePixelShader(device, object->data,
+ (IDirect3DPixelShader9 **)param->data)))
+ {
+ WARN("Failed to create pixel shader.\n");
+ return D3D_OK;
+ }
+ break;
+ default:
+ break;
+ }
+ return D3D_OK;
+}
+
+static HRESULT d3dx9_parse_array_selector(struct d3dx9_base_effect *base, struct d3dx_state *state,
+ const char **skip_constants, unsigned int skip_constants_count)
+{
+ DWORD string_size;
+ struct d3dx_parameter *param = &state->parameter;
+ struct d3dx_object *object = &base->objects[param->object_id];
+ char *ptr = object->data;
+ HRESULT ret;
+
+ TRACE("Parsing array entry selection state for parameter %p.\n", param);
+
+ string_size = *(DWORD *)ptr;
+ state->referenced_param = get_parameter_by_name(base, NULL, ptr + 4);
+ if (state->referenced_param)
+ {
+ TRACE("Mapping to parameter %s.\n", debugstr_a(state->referenced_param->name));
+ }
+ else
+ {
+ FIXME("Referenced parameter %s not found.\n", ptr + 4);
+ return D3DXERR_INVALIDDATA;
+ }
+ TRACE("Unknown DWORD: 0x%.8x.\n", *(DWORD *)(ptr + string_size));
+
+ if (string_size % sizeof(DWORD))
+ FIXME("Unaligned string_size %u.\n", string_size);
+ if (FAILED(ret = d3dx_create_param_eval(base, (DWORD *)(ptr + string_size) + 1,
+ object->size - (string_size + sizeof(DWORD)), D3DXPT_INT, ¶m->param_eval,
+ get_version_counter_ptr(base), NULL, 0)))
+ return ret;
+ ret = D3D_OK;
+ param = state->referenced_param;
+ if (param->type == D3DXPT_VERTEXSHADER || param->type == D3DXPT_PIXELSHADER)
+ {
+ unsigned int i;
+
+ for (i = 0; i < param->element_count; i++)
+ {
+ if (param->members[i].type != param->type)
+ {
+ FIXME("Unexpected member parameter type %u, expected %u.\n", param->members[i].type, param->type);
+ return D3DXERR_INVALIDDATA;
+ }
+ if (!param->members[i].param_eval)
+ {
+ TRACE("Creating preshader for object %u.\n", param->members[i].object_id);
+ object = &base->objects[param->members[i].object_id];
+ if (FAILED(ret = d3dx_create_param_eval(base, object->data, object->size, param->type,
+ ¶m->members[i].param_eval, get_version_counter_ptr(base),
+ skip_constants, skip_constants_count)))
+ break;
+ }
+ }
+ }
+ return ret;
+}
+
+static HRESULT d3dx9_parse_resource(struct d3dx9_base_effect *base, const char *data, const char **ptr,
+ const char **skip_constants, unsigned int skip_constants_count)
{
DWORD technique_index;
DWORD index, state_index, usage, element_index;
struct d3dx_state *state;
struct d3dx_parameter *param;
+ struct d3dx_object *object;
HRESULT hr = E_FAIL;
read_dword(ptr, &technique_index);
- TRACE("techn: %u\n", technique_index);
+ TRACE("technique_index: %u\n", technique_index);
read_dword(ptr, &index);
TRACE("index: %u\n", index);
return E_FAIL;
}
- parameter = &base->parameters[index];
+ parameter = &base->parameters[index].param;
if (element_index != 0xffffffff)
{
if (element_index >= parameter->element_count && parameter->element_count != 0)
return E_FAIL;
}
- if (parameter->element_count != 0) parameter = ¶meter->members[element_index];
+ if (parameter->element_count)
+ parameter = ¶meter->members[element_index];
}
sampler = parameter->data;
state = &pass->states[state_index];
}
- param = state->parameter;
+ TRACE("State operation %#x (%s).\n", state->operation, state_table[state->operation].name);
+ param = &state->parameter;
+ TRACE("Using object id %u.\n", param->object_id);
+ object = &base->objects[param->object_id];
+ TRACE("Usage %u: class %s, type %s.\n", usage, debug_d3dxparameter_class(param->class),
+ debug_d3dxparameter_type(param->type));
switch (usage)
{
case 0:
- TRACE("usage 0: type %s\n", debug_d3dxparameter_type(param->type));
switch (param->type)
{
case D3DXPT_VERTEXSHADER:
case D3DXPT_PIXELSHADER:
state->type = ST_CONSTANT;
- hr = d3dx9_parse_data(param, ptr, base->effect->device);
+ if (FAILED(hr = d3dx9_copy_data(base, param->object_id, ptr)))
+ return hr;
+
+ if (object->data)
+ {
+ if (FAILED(hr = d3dx9_create_object(base, object)))
+ return hr;
+ if (FAILED(hr = d3dx_create_param_eval(base, object->data, object->size, param->type,
+ ¶m->param_eval, get_version_counter_ptr(base),
+ skip_constants, skip_constants_count)))
+ return hr;
+ }
break;
case D3DXPT_BOOL:
case D3DXPT_FLOAT:
case D3DXPT_STRING:
state->type = ST_FXLC;
- hr = d3dx9_copy_data(param->data, ptr);
+ if (FAILED(hr = d3dx9_copy_data(base, param->object_id, ptr)))
+ return hr;
+ if (FAILED(hr = d3dx_create_param_eval(base, object->data, object->size, param->type,
+ ¶m->param_eval, get_version_counter_ptr(base), NULL, 0)))
+ return hr;
break;
default:
case 1:
state->type = ST_PARAMETER;
- hr = d3dx9_copy_data(param->data, ptr);
- if (hr == D3D_OK)
+ if (FAILED(hr = d3dx9_copy_data(base, param->object_id, ptr)))
+ return hr;
+
+ TRACE("Looking for parameter %s.\n", debugstr_a(object->data));
+ state->referenced_param = get_parameter_by_name(base, NULL, object->data);
+ if (state->referenced_param)
+ {
+ struct d3dx_parameter *refpar = state->referenced_param;
+
+ TRACE("Mapping to parameter %p, having object id %u.\n", refpar, refpar->object_id);
+ if (refpar->type == D3DXPT_VERTEXSHADER || refpar->type == D3DXPT_PIXELSHADER)
+ {
+ struct d3dx_object *refobj = &base->objects[refpar->object_id];
+
+ if (!refpar->param_eval)
+ {
+ if (FAILED(hr = d3dx_create_param_eval(base, refobj->data, refobj->size,
+ refpar->type, &refpar->param_eval, get_version_counter_ptr(base),
+ skip_constants, skip_constants_count)))
+ return hr;
+ }
+ }
+ }
+ else
{
- TRACE("Mapping to parameter %s\n", *(char **)param->data);
+ FIXME("Referenced parameter %s not found.\n", (char *)object->data);
+ return D3DXERR_INVALIDDATA;
}
break;
+ case 2:
+ state->type = ST_ARRAY_SELECTOR;
+ if (FAILED(hr = d3dx9_copy_data(base, param->object_id, ptr)))
+ return hr;
+ hr = d3dx9_parse_array_selector(base, state, skip_constants, skip_constants_count);
+ break;
+
default:
FIXME("Unknown usage %x\n", usage);
break;
return hr;
}
-static HRESULT d3dx9_parse_effect(struct d3dx9_base_effect *base, const char *data, UINT data_size, DWORD start)
+static BOOL param_set_top_level_param(void *top_level_param, struct d3dx_parameter *param)
+{
+ param->top_level_param = top_level_param;
+ return FALSE;
+}
+
+static HRESULT d3dx9_parse_effect(struct d3dx9_base_effect *base, const char *data, UINT data_size,
+ DWORD start, const char **skip_constants, unsigned int skip_constants_count)
{
const char *ptr = data + start;
- D3DXHANDLE *objects = NULL;
- UINT stringcount, objectcount, resourcecount;
+ UINT stringcount, resourcecount;
HRESULT hr;
UINT i;
read_dword(&ptr, &base->parameter_count);
- TRACE("Parameter count: %u\n", base->parameter_count);
+ TRACE("Parameter count: %u.\n", base->parameter_count);
read_dword(&ptr, &base->technique_count);
- TRACE("Technique count: %u\n", base->technique_count);
+ TRACE("Technique count: %u.\n", base->technique_count);
skip_dword_unknown(&ptr, 1);
- read_dword(&ptr, &objectcount);
- TRACE("Object count: %u\n", objectcount);
+ read_dword(&ptr, &base->object_count);
+ TRACE("Object count: %u.\n", base->object_count);
- objects = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*objects) * objectcount);
- if (!objects)
+ base->objects = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*base->objects) * base->object_count);
+ if (!base->objects)
{
- ERR("Out of memory\n");
+ ERR("Out of memory.\n");
hr = E_OUTOFMEMORY;
goto err_out;
}
sizeof(*base->parameters) * base->parameter_count);
if (!base->parameters)
{
- ERR("Out of memory\n");
+ ERR("Out of memory.\n");
hr = E_OUTOFMEMORY;
goto err_out;
}
for (i = 0; i < base->parameter_count; ++i)
{
- hr = d3dx9_parse_effect_parameter(&base->parameters[i], data, &ptr, objects);
+ param_set_magic_number(&base->parameters[i].param);
+ hr = d3dx9_parse_effect_parameter(base, &base->parameters[i], data, &ptr, base->objects);
if (hr != D3D_OK)
{
- WARN("Failed to parse parameter %u\n", i);
+ WARN("Failed to parse parameter %u.\n", i);
goto err_out;
}
+ walk_parameter_tree(&base->parameters[i].param, param_set_top_level_param,
+ &base->parameters[i]);
}
}
sizeof(*base->techniques) * base->technique_count);
if (!base->techniques)
{
- ERR("Out of memory\n");
+ ERR("Out of memory.\n");
hr = E_OUTOFMEMORY;
goto err_out;
}
for (i = 0; i < base->technique_count; ++i)
{
- hr = d3dx9_parse_effect_technique(&base->techniques[i], data, &ptr, objects);
+ TRACE("Parsing technique %u.\n", i);
+ hr = d3dx9_parse_effect_technique(base, &base->techniques[i], data, &ptr, base->objects);
if (hr != D3D_OK)
{
- WARN("Failed to parse technique %u\n", i);
+ WARN("Failed to parse technique %u.\n", i);
goto err_out;
}
}
}
read_dword(&ptr, &stringcount);
- TRACE("String count: %u\n", stringcount);
+ TRACE("String count: %u.\n", stringcount);
read_dword(&ptr, &resourcecount);
- TRACE("Resource count: %u\n", resourcecount);
+ TRACE("Resource count: %u.\n", resourcecount);
for (i = 0; i < stringcount; ++i)
{
DWORD id;
- struct d3dx_parameter *param;
read_dword(&ptr, &id);
- TRACE("Id: %u\n", id);
+ TRACE("id: %u.\n", id);
- param = get_parameter_struct(objects[id]);
+ if (FAILED(hr = d3dx9_copy_data(base, id, &ptr)))
+ goto err_out;
- hr = d3dx9_parse_data(param, &ptr, base->effect->device);
- if (hr != D3D_OK)
+ if (base->objects[id].data)
{
- WARN("Failed to parse data %u\n", i);
- goto err_out;
+ if (FAILED(hr = d3dx9_create_object(base, &base->objects[id])))
+ goto err_out;
}
}
for (i = 0; i < resourcecount; ++i)
{
- TRACE("parse resource %u\n", i);
+ TRACE("parse resource %u.\n", i);
- hr = d3dx9_parse_resource(base, data, &ptr);
+ hr = d3dx9_parse_resource(base, data, &ptr, skip_constants, skip_constants_count);
if (hr != D3D_OK)
{
- WARN("Failed to parse resource %u\n", i);
+ WARN("Failed to parse resource %u.\n", i);
goto err_out;
}
}
- HeapFree(GetProcessHeap(), 0, objects);
-
+ for (i = 0; i < base->parameter_count; ++i)
+ {
+ if (FAILED(hr = d3dx_pool_sync_shared_parameter(base->pool, &base->parameters[i])))
+ goto err_out;
+ base->parameters[i].version_counter = base->pool
+ ? &base->pool->version_counter
+ : &base->version_counter;
+ set_dirty(&base->parameters[i].param);
+ }
return D3D_OK;
err_out:
{
for (i = 0; i < base->parameter_count; ++i)
{
- free_parameter(&base->parameters[i], FALSE, FALSE);
+ free_top_level_parameter(&base->parameters[i]);
}
HeapFree(GetProcessHeap(), 0, base->parameters);
base->parameters = NULL;
}
- HeapFree(GetProcessHeap(), 0, objects);
+ if (base->objects)
+ {
+ for (i = 0; i < base->object_count; ++i)
+ {
+ free_object(&base->objects[i]);
+ }
+ HeapFree(GetProcessHeap(), 0, base->objects);
+ base->objects = NULL;
+ }
return hr;
}
+#define INITIAL_CONST_NAMES_SIZE 4
+
+static char *next_valid_constant_name(char **string)
+{
+ char *ret = *string;
+ char *next;
+
+ while (*ret && !isalpha(*ret) && *ret != '_')
+ ++ret;
+ if (!*ret)
+ return NULL;
+
+ next = ret + 1;
+ while (isalpha(*next) || isdigit(*next) || *next == '_')
+ ++next;
+ if (*next)
+ *next++ = 0;
+ *string = next;
+ return ret;
+}
+
+static const char **parse_skip_constants_string(char *skip_constants_string, unsigned int *names_count)
+{
+ const char **names, **new_alloc;
+ const char *name;
+ char *s;
+ unsigned int size = INITIAL_CONST_NAMES_SIZE;
+
+ names = HeapAlloc(GetProcessHeap(), 0, sizeof(*names) * size);
+ if (!names)
+ return NULL;
+
+ *names_count = 0;
+ s = skip_constants_string;
+ while ((name = next_valid_constant_name(&s)))
+ {
+ if (*names_count == size)
+ {
+ size *= 2;
+ new_alloc = HeapReAlloc(GetProcessHeap(), 0, names, sizeof(*names) * size);
+ if (!new_alloc)
+ {
+ HeapFree(GetProcessHeap(), 0, names);
+ return NULL;
+ }
+ names = new_alloc;
+ }
+ names[(*names_count)++] = name;
+ }
+ new_alloc = HeapReAlloc(GetProcessHeap(), 0, names, *names_count * sizeof(*names));
+ if (!new_alloc)
+ return names;
+ return new_alloc;
+}
+
static HRESULT d3dx9_base_effect_init(struct d3dx9_base_effect *base,
- const char *data, SIZE_T data_size, struct ID3DXEffectImpl *effect)
+ const char *data, SIZE_T data_size, const D3D_SHADER_MACRO *defines, ID3DInclude *include,
+ UINT eflags, ID3DBlob **errors, struct ID3DXEffectImpl *effect, struct d3dx_effect_pool *pool,
+ const char *skip_constants_string)
{
DWORD tag, offset;
const char *ptr = data;
HRESULT hr;
+ ID3DBlob *bytecode = NULL, *temp_errors = NULL;
+ char *skip_constants_buffer = NULL;
+ const char **skip_constants = NULL;
+ unsigned int skip_constants_count = 0;
+ unsigned int i, j;
- TRACE("base %p, data %p, data_size %lu, effect %p\n", base, data, data_size, effect);
+ TRACE("base %p, data %p, data_size %lu, effect %p, pool %p, skip_constants %s.\n",
+ base, data, data_size, effect, pool, debugstr_a(skip_constants_string));
base->effect = effect;
+ base->pool = pool;
+ base->flags = eflags;
read_dword(&ptr, &tag);
TRACE("Tag: %x\n", tag);
if (tag != d3dx9_effect_version(9, 1))
{
- /* todo: compile hlsl ascii code */
- FIXME("HLSL ascii effects not supported, yet\n");
+ TRACE("HLSL ASCII effect, trying to compile it.\n");
+ hr = D3DCompile(data, data_size, NULL, defines, include,
+ "main", "fx_2_0", 0, eflags, &bytecode, &temp_errors);
+ if (FAILED(hr))
+ {
+ WARN("Failed to compile ASCII effect.\n");
+ if (bytecode)
+ ID3D10Blob_Release(bytecode);
+ if (temp_errors)
+ {
+ const char *error_string = ID3D10Blob_GetBufferPointer(temp_errors);
+ const char *string_ptr;
+
+ while (*error_string)
+ {
+ string_ptr = error_string;
+ while (*string_ptr && *string_ptr != '\n' && *string_ptr != '\r'
+ && string_ptr - error_string < 80)
+ ++string_ptr;
+ TRACE("%s\n", debugstr_an(error_string, string_ptr - error_string));
+ error_string = string_ptr;
+ while (*error_string == '\n' || *error_string == '\r')
+ ++error_string;
+ }
+ }
+ if (errors)
+ *errors = temp_errors;
+ else if (temp_errors)
+ ID3D10Blob_Release(temp_errors);
+ return hr;
+ }
+ if (!bytecode)
+ {
+ FIXME("No output from effect compilation.\n");
+ return D3DERR_INVALIDCALL;
+ }
+ if (errors)
+ *errors = temp_errors;
+ else if (temp_errors)
+ ID3D10Blob_Release(temp_errors);
- /* Show the start of the shader for debugging info. */
- TRACE("effect:\n%s\n", debugstr_an(data, data_size > 40 ? 40 : data_size));
+ ptr = ID3D10Blob_GetBufferPointer(bytecode);
+ read_dword(&ptr, &tag);
+ TRACE("Tag: %x\n", tag);
}
- else
+
+ if (skip_constants_string)
+ {
+ skip_constants_buffer = HeapAlloc(GetProcessHeap(), 0,
+ sizeof(*skip_constants_buffer) * (strlen(skip_constants_string) + 1));
+ if (!skip_constants_buffer)
+ {
+ if (bytecode)
+ ID3D10Blob_Release(bytecode);
+ return E_OUTOFMEMORY;
+ }
+ strcpy(skip_constants_buffer, skip_constants_string);
+
+ if (!(skip_constants = parse_skip_constants_string(skip_constants_buffer, &skip_constants_count)))
+ {
+ HeapFree(GetProcessHeap(), 0, skip_constants_buffer);
+ if (bytecode)
+ ID3D10Blob_Release(bytecode);
+ return E_OUTOFMEMORY;
+ }
+ }
+ read_dword(&ptr, &offset);
+ TRACE("Offset: %x\n", offset);
+
+ hr = d3dx9_parse_effect(base, ptr, data_size, offset, skip_constants, skip_constants_count);
+ if (bytecode)
+ ID3D10Blob_Release(bytecode);
+ if (hr != D3D_OK)
{
- read_dword(&ptr, &offset);
- TRACE("Offset: %x\n", offset);
+ FIXME("Failed to parse effect.\n");
+ HeapFree(GetProcessHeap(), 0, skip_constants_buffer);
+ HeapFree(GetProcessHeap(), 0, skip_constants);
+ return hr;
+ }
- hr = d3dx9_parse_effect(base, ptr, data_size, offset);
- if (hr != D3D_OK)
+ for (i = 0; i < skip_constants_count; ++i)
+ {
+ struct d3dx_parameter *param;
+ param = get_parameter_by_name(base, NULL, skip_constants[i]);
+ if (param)
{
- FIXME("Failed to parse effect.\n");
- return hr;
+ for (j = 0; j < base->technique_count; ++j)
+ {
+ if (is_parameter_used(param, &base->techniques[j]))
+ {
+ WARN("skip_constants parameter %s is used in technique %u.\n",
+ debugstr_a(skip_constants[i]), j);
+ HeapFree(GetProcessHeap(), 0, skip_constants_buffer);
+ HeapFree(GetProcessHeap(), 0, skip_constants);
+ d3dx9_base_effect_cleanup(base);
+ return D3DERR_INVALIDCALL;
+ }
+ }
+ }
+ else
+ {
+ TRACE("skip_constants parameter %s not found.\n",
+ debugstr_a(skip_constants[i]));
}
}
+ HeapFree(GetProcessHeap(), 0, skip_constants_buffer);
+ HeapFree(GetProcessHeap(), 0, skip_constants);
+
return D3D_OK;
}
static HRESULT d3dx9_effect_init(struct ID3DXEffectImpl *effect, struct IDirect3DDevice9 *device,
- const char *data, SIZE_T data_size, struct ID3DXEffectPool *pool)
+ const char *data, SIZE_T data_size, const D3D_SHADER_MACRO *defines, ID3DInclude *include,
+ UINT eflags, ID3DBlob **error_messages, struct ID3DXEffectPool *pool, const char *skip_constants)
{
HRESULT hr;
+ struct d3dx_effect_pool *pool_impl = NULL;
TRACE("effect %p, device %p, data %p, data_size %lu, pool %p\n", effect, device, data, data_size, pool);
effect->ID3DXEffect_iface.lpVtbl = &ID3DXEffect_Vtbl;
effect->ref = 1;
- if (pool) pool->lpVtbl->AddRef(pool);
+ if (pool)
+ {
+ pool->lpVtbl->AddRef(pool);
+ pool_impl = impl_from_ID3DXEffectPool(pool);
+ }
effect->pool = pool;
IDirect3DDevice9_AddRef(device);
effect->device = device;
- if (FAILED(hr = d3dx9_base_effect_init(&effect->base_effect, data, data_size, effect)))
+ if (FAILED(hr = d3dx9_base_effect_init(&effect->base_effect, data, data_size, defines, include,
+ eflags, error_messages, effect, pool_impl, skip_constants)))
{
FIXME("Failed to parse effect, hr %#x.\n", hr);
free_effect(effect);
struct ID3DXEffectImpl *object;
HRESULT hr;
- FIXME("(%p, %p, %u, %p, %p, %p, %#x, %p, %p, %p): semi-stub\n", device, srcdata, srcdatalen, defines, include,
- skip_constants, flags, pool, effect, compilation_errors);
+ TRACE("device %p, srcdata %p, srcdatalen %u, defines %p, include %p,"
+ " skip_constants %p, flags %#x, pool %p, effect %p, compilation_errors %p.\n",
+ device, srcdata, srcdatalen, defines, include,
+ skip_constants, flags, pool, effect, compilation_errors);
if (compilation_errors)
*compilation_errors = NULL;
if (!object)
return E_OUTOFMEMORY;
- hr = d3dx9_effect_init(object, device, srcdata, srcdatalen, pool);
+ hr = d3dx9_effect_init(object, device, srcdata, srcdatalen, (const D3D_SHADER_MACRO *)defines,
+ (ID3DInclude *)include, flags, (ID3DBlob **)compilation_errors, pool, skip_constants);
if (FAILED(hr))
{
- WARN("Failed to initialize shader reflection\n");
+ WARN("Failed to create effect object.\n");
HeapFree(GetProcessHeap(), 0, object);
return hr;
}
return D3DXCreateEffectEx(device, srcdata, srcdatalen, defines, include, NULL, flags, pool, effect, compilation_errors);
}
-static HRESULT d3dx9_effect_compiler_init(struct ID3DXEffectCompilerImpl *compiler, const char *data, SIZE_T data_size)
+static HRESULT d3dx9_effect_compiler_init(struct ID3DXEffectCompilerImpl *compiler,
+ const char *data, SIZE_T data_size, const D3D_SHADER_MACRO *defines, ID3DInclude *include,
+ UINT eflags, ID3DBlob **error_messages)
{
HRESULT hr;
compiler->ID3DXEffectCompiler_iface.lpVtbl = &ID3DXEffectCompiler_Vtbl;
compiler->ref = 1;
- if (FAILED(hr = d3dx9_base_effect_init(&compiler->base_effect, data, data_size, NULL)))
+ if (FAILED(hr = d3dx9_base_effect_init(&compiler->base_effect, data, data_size, defines,
+ include, eflags, error_messages, NULL, NULL, NULL)))
{
FIXME("Failed to parse effect, hr %#x.\n", hr);
free_effect_compiler(compiler);
if (!object)
return E_OUTOFMEMORY;
- hr = d3dx9_effect_compiler_init(object, srcdata, srcdatalen);
+ hr = d3dx9_effect_compiler_init(object, srcdata, srcdatalen, (const D3D_SHADER_MACRO *)defines,
+ (ID3DInclude *)include, flags, (ID3DBlob **)parse_errors);
if (FAILED(hr))
{
WARN("Failed to initialize effect compiler\n");
return D3D_OK;
}
-struct ID3DXEffectPoolImpl
-{
- ID3DXEffectPool ID3DXEffectPool_iface;
- LONG ref;
-};
-
-static inline struct ID3DXEffectPoolImpl *impl_from_ID3DXEffectPool(ID3DXEffectPool *iface)
-{
- return CONTAINING_RECORD(iface, struct ID3DXEffectPoolImpl, ID3DXEffectPool_iface);
-}
-
/*** IUnknown methods ***/
-static HRESULT WINAPI ID3DXEffectPoolImpl_QueryInterface(ID3DXEffectPool *iface, REFIID riid, void **object)
+static HRESULT WINAPI d3dx_effect_pool_QueryInterface(ID3DXEffectPool *iface, REFIID riid, void **object)
{
- TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), object);
+ TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
if (IsEqualGUID(riid, &IID_IUnknown) ||
IsEqualGUID(riid, &IID_ID3DXEffectPool))
return E_NOINTERFACE;
}
-static ULONG WINAPI ID3DXEffectPoolImpl_AddRef(ID3DXEffectPool *iface)
+static ULONG WINAPI d3dx_effect_pool_AddRef(ID3DXEffectPool *iface)
{
- struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
+ struct d3dx_effect_pool *pool = impl_from_ID3DXEffectPool(iface);
+ ULONG refcount = InterlockedIncrement(&pool->refcount);
- TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
+ TRACE("%p increasing refcount to %u.\n", pool, refcount);
- return InterlockedIncrement(&This->ref);
+ return refcount;
}
-static ULONG WINAPI ID3DXEffectPoolImpl_Release(ID3DXEffectPool *iface)
+static void free_effect_pool(struct d3dx_effect_pool *pool)
{
- struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
- ULONG ref = InterlockedDecrement(&This->ref);
+ unsigned int i;
- TRACE("(%p)->(): Release from %u\n", This, ref + 1);
+ for (i = 0; i < pool->size; ++i)
+ {
+ if (pool->shared_data[i].count)
+ {
+ unsigned int j;
- if (!ref)
- HeapFree(GetProcessHeap(), 0, This);
+ WARN("Releasing pool with referenced parameters.\n");
- return ref;
+ param_set_data_pointer(&pool->shared_data[i].parameters[0]->param, NULL, FALSE, TRUE);
+ pool->shared_data[i].parameters[0]->shared_data = NULL;
+
+ for (j = 1; j < pool->shared_data[i].count; ++j)
+ {
+ walk_parameter_tree(&pool->shared_data[i].parameters[j]->param, param_zero_data_func, NULL);
+ pool->shared_data[i].parameters[j]->shared_data = NULL;
+ }
+ HeapFree(GetProcessHeap(), 0, pool->shared_data[i].parameters);
+ }
+ }
+ HeapFree(GetProcessHeap(), 0, pool->shared_data);
+ HeapFree(GetProcessHeap(), 0, pool);
+}
+
+static ULONG WINAPI d3dx_effect_pool_Release(ID3DXEffectPool *iface)
+{
+ struct d3dx_effect_pool *pool = impl_from_ID3DXEffectPool(iface);
+ ULONG refcount = InterlockedDecrement(&pool->refcount);
+
+ TRACE("%p decreasing refcount to %u.\n", pool, refcount);
+
+ if (!refcount)
+ free_effect_pool(pool);
+
+ return refcount;
}
static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl =
{
/*** IUnknown methods ***/
- ID3DXEffectPoolImpl_QueryInterface,
- ID3DXEffectPoolImpl_AddRef,
- ID3DXEffectPoolImpl_Release
+ d3dx_effect_pool_QueryInterface,
+ d3dx_effect_pool_AddRef,
+ d3dx_effect_pool_Release
};
HRESULT WINAPI D3DXCreateEffectPool(ID3DXEffectPool **pool)
{
- struct ID3DXEffectPoolImpl *object;
+ struct d3dx_effect_pool *object;
- TRACE("(%p)\n", pool);
+ TRACE("pool %p.\n", pool);
if (!pool)
return D3DERR_INVALIDCALL;
return E_OUTOFMEMORY;
object->ID3DXEffectPool_iface.lpVtbl = &ID3DXEffectPool_Vtbl;
- object->ref = 1;
+ object->refcount = 1;
*pool = &object->ID3DXEffectPool_iface;
const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skipconstants, DWORD flags,
struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
{
- LPVOID buffer;
+ void *buffer;
HRESULT ret;
DWORD size;
- TRACE("(%s): relay\n", debugstr_w(srcfile));
+ TRACE("device %p, srcfile %s, defines %p, include %p, skipconstants %s, "
+ "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
+ device, debugstr_w(srcfile), defines, include, debugstr_a(skipconstants),
+ flags, pool, effect, compilationerrors);
if (!device || !srcfile)
return D3DERR_INVALIDCALL;
const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skipconstants, DWORD flags,
struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
{
- LPWSTR srcfileW;
+ WCHAR *srcfileW;
HRESULT ret;
DWORD len;
- TRACE("(void): relay\n");
+ TRACE("device %p, srcfile %s, defines %p, include %p, skipconstants %s, "
+ "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
+ device, debugstr_a(srcfile), defines, include, debugstr_a(skipconstants),
+ flags, pool, effect, compilationerrors);
if (!srcfile)
return D3DERR_INVALIDCALL;
HRESULT WINAPI D3DXCreateEffectCompilerFromFileW(const WCHAR *srcfile, const D3DXMACRO *defines,
ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors)
{
- LPVOID buffer;
+ void *buffer;
HRESULT ret;
DWORD size;
- TRACE("(%s): relay\n", debugstr_w(srcfile));
+ TRACE("srcfile %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
+ debugstr_w(srcfile), defines, include, flags, effectcompiler, parseerrors);
if (!srcfile)
return D3DERR_INVALIDCALL;
HRESULT WINAPI D3DXCreateEffectCompilerFromFileA(const char *srcfile, const D3DXMACRO *defines,
ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors)
{
- LPWSTR srcfileW;
+ WCHAR *srcfileW;
HRESULT ret;
DWORD len;
- TRACE("(void): relay\n");
+ TRACE("srcfile %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
+ debugstr_a(srcfile), defines, include, flags, effectcompiler, parseerrors);
if (!srcfile)
return D3DERR_INVALIDCALL;
projects / reactos.git / blobdiff