[v3 2/6] d3dx9: add preshaders to effect.
Paul Gofman
gofmanp at gmail.com
Thu Mar 10 08:23:08 CST 2016
Signed-off-by: Paul Gofman <gofmanp at gmail.com>
---
CHANGES
Add preshader.c to Makefile.in in alphabetic order;
Renamed struct d3dx_preshader to d3dx_param_eval;
Renamed 'pres' member of d3dx_parameter to param_eval;
Renamed struct d3dx_fxlc to d3dx_preshader, and local vars fxlc to pres;
Renamed local variables and function parameters 'pres' to 'peval' in preshader.c;
Renamed enum preshader_type to enum param_eval_type (enum members prefix is now PEVAL_TYPE_);
Introduced a separate structure for register table data and functions for accessing it;
Used min/max already defined instead of introducing MIN/MAX macros;
Renamed PO_... to PRESHADER_OP_... in enum PRES_OPS;
Changed hex constants to lowercase in defines;
Rename enum PRES_TABLES to PRES_REG_TABLES;
Renamed constants in enum PRES_REG_TABLES to PRES_REGTAB_..., removed most of comments;
Clarified comment for 'offset' field in struct d3dx_pres_operand
Comment formatting in struct d3dx_pres_ins
Dump_preshader_bytecode: change MESSAGE to TRACE, output 8 words per line;
Use PRES_REGTAB_IMMED instead of 1 in parse_pres_arg;
Fixed typo in "returning OK is not a typo" comment;
Use sizeof(*val) instead of sizeof(type) in HeapAlloc's
Fixed some formatting issues (no space around '/', 'continue' not on its own line,
no space before final '/' in multiline macro);
Changed all DWORDs to unsigned ints;
dlls/d3dx9_36/Makefile.in | 1 +
dlls/d3dx9_36/d3dx9_36_private.h | 36 ++
dlls/d3dx9_36/effect.c | 80 +++--
dlls/d3dx9_36/preshader.c | 686 +++++++++++++++++++++++++++++++++++++++
4 files changed, 771 insertions(+), 32 deletions(-)
create mode 100644 dlls/d3dx9_36/preshader.c
diff --git a/dlls/d3dx9_36/Makefile.in b/dlls/d3dx9_36/Makefile.in
index 95e3045..83f7d1c 100644
--- a/dlls/d3dx9_36/Makefile.in
+++ b/dlls/d3dx9_36/Makefile.in
@@ -11,6 +11,7 @@ C_SRCS = \
line.c \
math.c \
mesh.c \
+ preshader.c \
render.c \
shader.c \
skin.c \
diff --git a/dlls/d3dx9_36/d3dx9_36_private.h b/dlls/d3dx9_36/d3dx9_36_private.h
index 79f3b76..64cb40d 100644
--- a/dlls/d3dx9_36/d3dx9_36_private.h
+++ b/dlls/d3dx9_36/d3dx9_36_private.h
@@ -110,4 +110,40 @@ const char *debug_d3dxparameter_registerset(D3DXREGISTER_SET r) DECLSPEC_HIDDEN;
void set_number(void *outdata, D3DXPARAMETER_TYPE outtype,
const void *indata, D3DXPARAMETER_TYPE intype) DECLSPEC_HIDDEN;
+struct d3dx_param_eval;
+
+struct d3dx_parameter
+{
+ char *name;
+ char *semantic;
+ 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;
+ DWORD object_id;
+
+ D3DXHANDLE handle;
+
+ struct d3dx_parameter *annotations;
+ struct d3dx_parameter *members;
+
+ struct d3dx_parameter *referenced_param;
+ struct d3dx_param_eval *param_eval;
+};
+
+struct d3dx9_base_effect;
+
+struct d3dx_parameter *get_parameter_by_name(struct d3dx9_base_effect *base,
+ struct d3dx_parameter *parameter, const char *name) DECLSPEC_HIDDEN;
+
+HRESULT d3dx_create_param_eval(struct d3dx9_base_effect *base_effect, void *byte_code,
+ unsigned int byte_code_size, D3DXPARAMETER_TYPE type, struct d3dx_param_eval **peval) DECLSPEC_HIDDEN;
+void d3dx_free_param_eval(struct d3dx_param_eval *peval) DECLSPEC_HIDDEN;
+
#endif /* __WINE_D3DX9_36_PRIVATE_H */
diff --git a/dlls/d3dx9_36/effect.c b/dlls/d3dx9_36/effect.c
index e42cf86..92ce0b4 100644
--- a/dlls/d3dx9_36/effect.c
+++ b/dlls/d3dx9_36/effect.c
@@ -99,30 +99,6 @@ enum STATE_TYPE
ST_ARRAY_SELECTOR,
};
-struct d3dx_parameter
-{
- char *name;
- char *semantic;
- 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;
- DWORD object_id;
-
- D3DXHANDLE handle;
-
- struct d3dx_parameter *annotations;
- struct d3dx_parameter *members;
-
- struct d3dx_parameter *referenced_param;
-};
-
struct d3dx_object
{
UINT size;
@@ -211,8 +187,6 @@ 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 d3dx9_base_effect *base, struct d3dx_state *state,
@@ -543,6 +517,12 @@ static void free_parameter(struct d3dx_parameter *param, BOOL element, BOOL chil
if (!param)
return;
+ if (param->param_eval)
+ {
+ d3dx_free_param_eval(param->param_eval);
+ param->param_eval = NULL;
+ }
+
if (param->annotations)
{
for (i = 0; i < param->annotation_count; ++i)
@@ -894,7 +874,7 @@ static struct d3dx_parameter *get_annotation_by_name(UINT count, struct d3dx_par
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;
@@ -5427,6 +5407,7 @@ static HRESULT d3dx9_parse_array_selector(struct d3dx9_base_effect *base, struct
DWORD string_size;
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);
@@ -5443,9 +5424,30 @@ static HRESULT d3dx9_parse_array_selector(struct d3dx9_base_effect *base, struct
}
TRACE("Unknown DWORD: 0x%.8x.\n", *(DWORD *)(ptr + string_size));
- FIXME("Parse preshader.\n");
+ d3dx_create_param_eval(base, (DWORD *)(ptr + string_size) + 1, object->size - (string_size + 1),
+ D3DXPT_INT, ¶m->param_eval);
+ ret = D3D_OK;
+ param = param->referenced_param;
+ if (param->type == D3DXPT_VERTEXSHADER || param->type == D3DXPT_PIXELSHADER)
+ {
+ unsigned int i;
- return D3D_OK;
+ for (i = 0; i < param->element_count; i++)
+ {
+ if (param->members[i].type != param->type)
+ {
+ FIXME("Unexpected member parameter type %u (need %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];
+ d3dx_create_param_eval(base, object->data, object->size, param->type, ¶m->members[i].param_eval);
+ }
+ }
+ }
+ return ret;
}
static HRESULT d3dx9_parse_resource(struct d3dx9_base_effect *base, const char *data, const char **ptr)
@@ -5551,7 +5553,11 @@ static HRESULT d3dx9_parse_resource(struct d3dx9_base_effect *base, const char *
return hr;
if (object->data)
- hr = d3dx9_create_object(base, object);
+ {
+ if (FAILED(hr = d3dx9_create_object(base, object)))
+ return hr;
+ d3dx_create_param_eval(base, object->data, object->size, param->type, ¶m->param_eval);
+ }
break;
case D3DXPT_BOOL:
@@ -5559,7 +5565,9 @@ static HRESULT d3dx9_parse_resource(struct d3dx9_base_effect *base, const char *
case D3DXPT_FLOAT:
case D3DXPT_STRING:
state->type = ST_FXLC;
- hr = d3dx9_copy_data(&base->objects[param->object_id], ptr);
+ if (FAILED(hr = d3dx9_copy_data(&base->objects[param->object_id], ptr)))
+ return hr;
+ d3dx_create_param_eval(base, object->data, object->size, param->type, ¶m->param_eval);
break;
default:
@@ -5577,7 +5585,15 @@ static HRESULT d3dx9_parse_resource(struct d3dx9_base_effect *base, const char *
param->referenced_param = get_parameter_by_name(base, NULL, object->data);
if (param->referenced_param)
{
- TRACE("Mapping to parameter %p.\n", param->referenced_param);
+ struct d3dx_parameter *refpar = param->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];
+
+ d3dx_create_param_eval(base, refobj->data, refobj->size, refpar->type, &refpar->param_eval);
+ }
}
else
{
diff --git a/dlls/d3dx9_36/preshader.c b/dlls/d3dx9_36/preshader.c
new file mode 100644
index 0000000..ca17743
--- /dev/null
+++ b/dlls/d3dx9_36/preshader.c
@@ -0,0 +1,686 @@
+/*
+ * FX preshader parsing & execution, setting shader constants
+ * from effect parameters.
+ *
+ * Copyright 2016 Paul Gofman
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "config.h"
+#include "wine/port.h"
+
+#include "windef.h"
+#include "wingdi.h"
+#include "d3dx9_36_private.h"
+
+#include "wine/debug.h"
+
+#include <float.h>
+
+WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
+
+enum param_eval_type
+{
+ PEVAL_TYPE_FXLC,
+ PEVAL_TYPE_SHADER
+};
+
+enum PRES_OPS
+{
+ PRESHADER_OP_NOP,
+ PRESHADER_OP_MOV,
+ PRESHADER_OP_MAX_ENUM
+};
+
+typedef float (*pres_op_func)(float *args, int ncomp);
+
+static float pres_mov(float *args, int ncomp) {return args[0];}
+
+#define PRES_OPCODE_MASK 0x7ff00000
+#define PRES_OPCODE_SHIFT 20
+#define PRES_SCALAR_FLAG 0x80000000
+#define PRES_NCOMP_MASK 0x0000ffff
+
+#define FOURCC_PRES 0x53455250
+#define FOURCC_CLIT 0x54494c43
+#define FOURCC_FXLC 0x434c5846
+#define FOURCC_PRSI 0x49535250
+#define PRES_SIGN 0x46580000
+
+struct op_info
+{
+ unsigned int opcode;
+ char mnem[8];
+ unsigned int ninp_args;
+ BOOL func_all_comps;
+ pres_op_func func;
+};
+
+static struct op_info pres_op_info[] =
+{
+ {0x000, "nop", 0, 0, NULL }, /* PRESHADER_OP_NOP */
+ {0x100, "mov", 1, 0, pres_mov}, /* PRESHADER_OP_MOV */
+};
+
+enum PRES_VALUE_TYPE
+{
+ PRES_VT_FLOAT,
+ PRES_VT_DOUBLE,
+ PRES_VT_INT,
+ PRES_VT_BOOL
+};
+
+enum PRES_REG_TABLES
+{
+ PRES_REGTAB_NONE,
+ PRES_REGTAB_IMMED, /* immediate double constants from CLIT */
+ PRES_REGTAB_CONST,
+ PRES_REGTAB_VERTEX, /* not used */
+ PRES_REGTAB_OCONST,
+ PRES_REGTAB_OBCONST,
+ PRES_REGTAB_OICONST,
+ PRES_REGTAB_REG,
+ PRES_REGTAB_MAX
+};
+
+static const struct
+{
+ unsigned int value_size;
+ unsigned int reg_value_cnt;
+ enum PRES_VALUE_TYPE type;
+}
+table_info[] =
+{
+ {0, 0},
+ {sizeof(double), 1, PRES_VT_DOUBLE}, /* PRES_REGTAB_IMMED */
+ {sizeof(float), 4, PRES_VT_FLOAT }, /* PRES_REGTAB_CONST */
+ {sizeof(float), 4, PRES_VT_FLOAT }, /* PRES_REGTAB_VERTEX */
+ {sizeof(float), 4, PRES_VT_FLOAT }, /* PRES_REGTAB_OCONST */
+ {sizeof(BOOL), 1, PRES_VT_BOOL }, /* PRES_REGTAB_OBCONST */
+ {sizeof(int), 4, PRES_VT_INT, }, /* PRES_REGTAB_OICONST */
+ {sizeof(float), 4, PRES_VT_FLOAT } /* PRES_REGTAB_REG */
+};
+
+static const char *table_symbol[] =
+{
+ "(null)", "imm", "c", "v", "oc", "ob", "oi", "r"
+};
+
+static const char *xyzw_str = "xyzw";
+
+#define OFFSET2REG(table, offset) ((offset) / table_info[table].reg_value_cnt)
+
+static const enum PRES_REG_TABLES pres_regset2table[] =
+{
+ PRES_REGTAB_OBCONST, /* D3DXRS_BOOL */
+ PRES_REGTAB_OICONST, /* D3DXRS_INT4 */
+ PRES_REGTAB_CONST, /* D3DXRS_FLOAT4 */
+ PRES_REGTAB_NONE, /* D3DXRS_SAMPLER */
+};
+
+static const enum PRES_REG_TABLES shad_regset2table[] =
+{
+ PRES_REGTAB_OBCONST, /* D3DXRS_BOOL */
+ PRES_REGTAB_OICONST, /* D3DXRS_INT4 */
+ PRES_REGTAB_OCONST, /* D3DXRS_FLOAT4 */
+ PRES_REGTAB_NONE, /* D3DXRS_SAMPLER */
+};
+
+struct d3dx_pres_operand
+{
+ enum PRES_REG_TABLES table;
+ /* offset is value index, not register index, e. g.
+ offset for value c3.y is 17 (3 * 4 + 1) */
+ unsigned int offset;
+};
+
+struct d3dx_pres_ins
+{
+ enum PRES_OPS op;
+ /* first input argument is scalar,
+ scalar component is propagated */
+ BOOL scalar_op;
+ unsigned int ncomps;
+ unsigned int ninp_args;
+ struct d3dx_pres_operand inputs[3];
+ struct d3dx_pres_operand output;
+};
+
+#define PRES_VS_BITS_PER_WORD (sizeof(unsigned int) * 8)
+
+struct d3dx_const_tab
+{
+ unsigned int ninputs;
+ D3DXCONSTANT_DESC *inputs;
+ struct d3dx_parameter **inputs_param;
+ ID3DXConstantTable *ctab;
+ /* TODO: do not keep input constant structure
+ (use it only at the parse stage) */
+ const enum PRES_REG_TABLES *regset2table;
+};
+
+struct d3dx_regstore
+{
+ void *tables[PRES_REGTAB_MAX];
+ unsigned int table_sizes[PRES_REGTAB_MAX]; /* registers count */
+ unsigned int *table_value_set[PRES_REGTAB_MAX];
+};
+
+struct d3dx_preshader
+{
+ struct d3dx_regstore regs;
+
+ unsigned int nins;
+ struct d3dx_pres_ins *ins;
+
+ struct d3dx_const_tab inputs;
+};
+
+struct d3dx_param_eval
+{
+ enum param_eval_type peval_type;
+ D3DXPARAMETER_TYPE param_type;
+
+ struct d3dx_preshader pres;
+ struct d3dx_const_tab shader_inputs;
+};
+
+static HRESULT regstore_alloc_table(struct d3dx_regstore *rs, unsigned int table)
+{
+ unsigned int sz;
+
+ sz = rs->table_sizes[table] * table_info[table].reg_value_cnt * table_info[table].value_size;
+ if (sz)
+ {
+ rs->tables[table] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz);
+ rs->table_value_set[table] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+ (rs->table_sizes[table] + PRES_VS_BITS_PER_WORD - 1) / PRES_VS_BITS_PER_WORD);
+ if (!rs->tables[table] || !rs->table_value_set[table])
+ return E_OUTOFMEMORY;
+ }
+ return D3D_OK;
+}
+
+static void regstore_free_tables(struct d3dx_regstore *rs)
+{
+ unsigned int i;
+
+ for (i = PRES_REGTAB_IMMED; i < PRES_REGTAB_MAX; i++)
+ {
+ if (rs->tables[i])
+ HeapFree(GetProcessHeap(), 0, rs->tables[i]);
+ if (rs->table_value_set[i])
+ HeapFree(GetProcessHeap(), 0, rs->table_value_set[i]);
+ }
+}
+
+static void regstore_set_values(struct d3dx_regstore *rs, unsigned int table, void *data,
+ unsigned int start_offset, unsigned int count)
+{
+ unsigned int reg_idx;
+ unsigned int reg_value_cnt;
+
+ if (!count) return ;
+
+ memcpy((BYTE *)rs->tables[table] + start_offset * table_info[table].value_size,
+ data, count * table_info[table].value_size);
+ reg_value_cnt = table_info[table].reg_value_cnt;
+ for (reg_idx = start_offset / reg_value_cnt; reg_idx <= (start_offset + count - 1) / reg_value_cnt; reg_idx++)
+ rs->table_value_set[table][reg_idx / PRES_VS_BITS_PER_WORD] |=
+ 1 << (reg_idx % PRES_VS_BITS_PER_WORD);
+}
+
+static void dump_shader_bytecode(void *data, unsigned int size)
+{
+ unsigned int *words = (unsigned int *)data;
+ unsigned int i, j, n;
+
+ size /= 4;
+ i = 0;
+ while (i < size)
+ {
+ n = min(size - i, 8);
+ for (j = 0; j < n; j++)
+ TRACE("0x%08X,", words[i + j]);
+ i += n;
+ TRACE("\n");
+ }
+}
+
+static unsigned int *find_bytecode_comment(unsigned int *ptr, unsigned int fourcc)
+{
+ while ((*ptr & 0xFFFF) == 0xFFFE)
+ {
+ if (*(ptr + 1) == fourcc)
+ return ptr + 2;
+ ptr += 1 + (*ptr >> 16);
+ }
+ return NULL;
+}
+
+static unsigned int *parse_pres_arg(unsigned int *ptr, struct d3dx_pres_operand *opr)
+{
+ if (*ptr != 0)
+ {
+ FIXME("Relative addressing not supported yet, word %#x.\n", *ptr);
+ return NULL;
+ }
+ ptr++;
+
+ if (*ptr < PRES_REGTAB_IMMED || *ptr >= PRES_REGTAB_MAX || *ptr == PRES_REGTAB_VERTEX)
+ {
+ FIXME("Unsupported argument table: %#x.\n", *ptr);
+ return NULL;
+ }
+ opr->table = *ptr;
+ ++ptr;
+ opr->offset = *ptr;
+ ++ptr;
+
+ if (opr->table == PRES_REGTAB_OBCONST)
+ opr->offset /= 4;
+ return ptr;
+}
+
+static unsigned int *parse_pres_ins(unsigned int *ptr, struct d3dx_pres_ins *ins)
+{
+ unsigned int ins_code, ins_raw;
+ unsigned int ninp_args;
+ unsigned int i;
+
+ ins_raw = *ptr;
+ ins_code = (ins_raw & PRES_OPCODE_MASK) >> PRES_OPCODE_SHIFT;
+ ins->ncomps = ins_raw & PRES_NCOMP_MASK;
+ ins->scalar_op = (ins_raw & PRES_SCALAR_FLAG) != 0;
+
+ if (ins->ncomps < 1 || ins->ncomps > 4)
+ {
+ FIXME("Unsupported number of components: %u.\n", ins->ncomps);
+ return NULL;
+ }
+ ++ptr;
+ ninp_args = *ptr++;
+ for (i = 0; i < PRESHADER_OP_MAX_ENUM; i++)
+ if (ins_code == pres_op_info[i].opcode)
+ break;
+ if (i == PRESHADER_OP_MAX_ENUM)
+ {
+ FIXME("Unknown opcode: %#x (raw %#x).\n", ins_code, ins_raw);
+ return NULL;
+ }
+ ins->op = i;
+ if (ninp_args != pres_op_info[i].ninp_args)
+ {
+ FIXME("Actual input args %u, expected %u, instruction %s.\n", ninp_args,
+ pres_op_info[i].ninp_args, pres_op_info[i].mnem);
+ return NULL;
+ }
+ ins->ninp_args = ninp_args;
+ for (i = 0; i < ninp_args; i++)
+ {
+ ptr = parse_pres_arg(ptr, &ins->inputs[i]);
+ if (ptr == NULL)
+ return NULL;
+ }
+ ptr = parse_pres_arg(ptr, &ins->output);
+ return ptr;
+}
+
+static HRESULT get_constants_desc(unsigned int *byte_code, struct d3dx_const_tab *out, struct d3dx9_base_effect *base)
+{
+ ID3DXConstantTable *ctab;
+ D3DXCONSTANT_DESC *cdesc;
+ struct d3dx_parameter **inputs_param;
+ D3DXCONSTANTTABLE_DESC desc;
+ HRESULT hr;
+ D3DXHANDLE hc;
+ unsigned int i;
+ unsigned int cnt;
+
+ out->inputs = cdesc = NULL;
+ out->ctab = NULL;
+ out->inputs_param = NULL;
+ out->ninputs = 0;
+ inputs_param = NULL;
+ hr = D3DXGetShaderConstantTable(byte_code, &ctab);
+ if (FAILED(hr) || !ctab)
+ {
+ TRACE("Could not get CTAB data, hr %#x.\n", hr);
+ /* returning OK is not a typo */
+ return D3D_OK;
+ }
+ hr = ID3DXConstantTable_GetDesc(ctab, &desc);
+ if (FAILED(hr))
+ {
+ FIXME("Could not get CTAB desc, hr %#x.\n", hr);
+ goto err_out;
+ }
+
+ cdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cdesc) * desc.Constants);
+ inputs_param = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*inputs_param) * desc.Constants);
+ for (i = 0; i < desc.Constants; i++)
+ {
+ hc = ID3DXConstantTable_GetConstant(ctab, NULL, i);
+ if (hc == NULL)
+ {
+ FIXME("Null constant handle.\n");
+ goto err_out;
+ }
+ cnt = 1;
+ hr = ID3DXConstantTable_GetConstantDesc(ctab, hc, &cdesc[i], &cnt);
+ if (FAILED(hr))
+ {
+ FIXME("Could not get constant desc, hr %#x.\n", hr);
+ goto err_out;
+ }
+ inputs_param[i] = get_parameter_by_name(base, NULL, cdesc[i].Name);
+ if (cdesc[i].Class == D3DXPC_OBJECT)
+ TRACE("Object %s, parameter %p.\n", cdesc[i].Name, inputs_param[i]);
+ else if (inputs_param[i] == NULL)
+ ERR("Could not find parameter %s in effect.\n", cdesc[i].Name);
+ }
+ out->ninputs = desc.Constants;
+ out->inputs = cdesc;
+ out->inputs_param = inputs_param;
+ out->ctab = ctab;
+ return D3D_OK;
+
+err_out:
+ if (cdesc)
+ HeapFree(GetProcessHeap(), 0, cdesc);
+ if (inputs_param)
+ HeapFree(GetProcessHeap(), 0, inputs_param);
+ if (ctab)
+ ID3DXConstantTable_Release(ctab);
+ return hr;
+}
+
+static void update_table_sizes_consts(unsigned int *table_sizes, struct d3dx_const_tab *ctab)
+{
+ unsigned int i, table, max_offset;
+
+ for (i = 0; i < ctab->ninputs; i++)
+ {
+ max_offset = ctab->inputs[i].RegisterIndex + ctab->inputs[i].RegisterCount;
+ table = ctab->regset2table[ctab->inputs[i].RegisterSet];
+ table_sizes[table] = max(table_sizes[table], max_offset);
+ }
+}
+
+static void dump_arg(struct d3dx_regstore *rs, struct d3dx_pres_operand *arg, int ncomps)
+{
+ unsigned int i, table;
+
+ table = arg->table;
+ if (table == PRES_REGTAB_IMMED)
+ {
+ TRACE("(");
+ for (i = 0; i < ncomps; i++)
+ TRACE(i < ncomps - 1 ? "%lf, " : "%lf", ((double *)rs->tables[PRES_REGTAB_IMMED])[arg->offset + i]);
+ TRACE(")");
+ }
+ else
+ {
+ TRACE("%s%u.", table_symbol[table], OFFSET2REG(table, arg->offset));
+ for (i = 0; i < ncomps; i++)
+ TRACE("%c", xyzw_str[(arg->offset + i) % 4]);
+ }
+}
+
+static void dump_registers(struct d3dx_const_tab *ctab)
+{
+ unsigned int table, i;
+
+ for (i = 0; i < ctab->ninputs; i++)
+ {
+ table = ctab->regset2table[ctab->inputs[i].RegisterSet];
+ TRACE("// %-12s %s%-4u %u\n", ctab->inputs_param[i] ? ctab->inputs_param[i]->name : "(nil)",
+ table_symbol[table], ctab->inputs[i].RegisterIndex, ctab->inputs[i].RegisterCount);
+ }
+}
+
+static void dump_ins(struct d3dx_regstore *rs, struct d3dx_pres_ins *ins)
+{
+ unsigned int i;
+
+ TRACE(" %s ", pres_op_info[ins->op].mnem);
+ dump_arg(rs, &ins->output, pres_op_info[ins->op].func_all_comps ? 1 : ins->ncomps);
+ for (i = 0; i < ins->ninp_args; i++)
+ {
+ TRACE(",");
+ dump_arg(rs, &ins->inputs[i], ins->scalar_op && !i ? 1 : ins->ncomps);
+ }
+ TRACE("\n");
+}
+
+static void dump_preshader(struct d3dx_preshader *pres)
+{
+ unsigned int i;
+
+ TRACE("// Preshader registers:\n");
+ dump_registers(&pres->inputs);
+ TRACE(" preshader\n");
+ for (i = 0; i < pres->nins; i++)
+ dump_ins(&pres->regs, &pres->ins[i]);
+}
+
+static HRESULT parse_preshader(struct d3dx_preshader *pres, unsigned int *ptr, struct d3dx9_base_effect *base)
+{
+ unsigned int *p;
+ unsigned int i, j, nconst, max_offset;
+ double *dconst;
+ HRESULT hr;
+ unsigned int saved_word;
+
+ TRACE("Preshader version: %#x.\n", *ptr & 0xFFFF);
+
+ p = find_bytecode_comment(ptr + 1, FOURCC_CLIT);
+ if (p)
+ {
+ nconst = *p;
+ dconst = (double *)(p + 1);
+ }
+ else
+ {
+ nconst = 0;
+ dconst = NULL;
+ }
+ TRACE("%u double constants.\n", nconst);
+
+ p = find_bytecode_comment(ptr + 1, FOURCC_FXLC);
+ if (!p)
+ {
+ WARN("Could not find preshader code.\n");
+ return D3D_OK;
+ }
+
+ pres->nins = *p;
+ TRACE("%u instructions.\n", pres->nins);
+ ++p;
+ pres->ins = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pres->ins) * pres->nins);
+ for (i = 0; i < pres->nins; i++)
+ {
+ p = parse_pres_ins(p, &pres->ins[i]);
+ if (p == NULL)
+ return D3DXERR_INVALIDDATA;
+ }
+
+ saved_word = *ptr;
+ *ptr = 0xfffe0000;
+ hr = get_constants_desc(ptr, &pres->inputs, base);
+ *ptr = saved_word;
+ if (FAILED(hr))
+ return hr;
+
+ pres->inputs.regset2table = pres_regset2table;
+
+ pres->regs.table_sizes[PRES_REGTAB_IMMED] = nconst;
+
+ for (i = 0; i < pres->nins; i++)
+ {
+ unsigned int table;
+
+ for (j = 0; j < pres->ins[i].ninp_args; j++)
+ {
+ table = pres->ins[i].inputs[j].table;
+ max_offset = OFFSET2REG(table, pres->ins[i].inputs[j].offset + pres->ins[i].ncomps - 1);
+ pres->regs.table_sizes[table] = max(pres->regs.table_sizes[table], max_offset + 1);
+ }
+ table = pres->ins[i].output.table;
+ max_offset = OFFSET2REG(table, pres->ins[i].output.offset + pres->ins[i].ncomps - 1);
+ pres->regs.table_sizes[table] = max(pres->regs.table_sizes[table], max_offset + 1);
+ }
+ update_table_sizes_consts(pres->regs.table_sizes, &pres->inputs);
+ if (FAILED(regstore_alloc_table(&pres->regs, PRES_REGTAB_IMMED)))
+ return E_OUTOFMEMORY;
+ regstore_set_values(&pres->regs, PRES_REGTAB_IMMED, dconst, 0, nconst);
+
+ return D3D_OK;
+}
+
+HRESULT d3dx_create_param_eval(struct d3dx9_base_effect *base_effect, void *byte_code, unsigned int byte_code_size,
+ D3DXPARAMETER_TYPE type, struct d3dx_param_eval **peval_out)
+{
+ struct d3dx_param_eval *peval;
+ HRESULT hr;
+ unsigned int *ptr;
+ unsigned int i;
+
+ TRACE("base_effect %p, byte_code %p, byte_code_size %u, type %u, peval_out %p.\n",
+ base_effect, byte_code, byte_code_size, type, peval_out);
+
+ if (byte_code == NULL)
+ {
+ *peval_out = NULL;
+ return D3DERR_INVALIDCALL;
+ }
+
+ hr = E_FAIL;
+ peval = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*peval));
+ if (!peval)
+ {
+ hr = E_OUTOFMEMORY;
+ goto err_out;
+ }
+
+ peval->param_type = type;
+ switch (type)
+ {
+ case D3DXPT_VERTEXSHADER:
+ case D3DXPT_PIXELSHADER:
+ peval->peval_type = PEVAL_TYPE_SHADER;
+ break;
+ default:
+ peval->peval_type = PEVAL_TYPE_FXLC;
+ break;
+ }
+ peval->shader_inputs.regset2table = shad_regset2table;
+
+ ptr = (unsigned int *)byte_code;
+ if (peval->peval_type == PEVAL_TYPE_SHADER)
+ {
+ if ((*ptr & 0xFFFE0000) != 0xFFFE0000)
+ {
+ FIXME("Invalid shader signature: %#x.\n", *ptr);
+ hr = D3DXERR_INVALIDDATA;
+ goto err_out;
+ }
+ TRACE("Shader version: %#x.\n", *ptr & 0xFFFF);
+
+ hr = get_constants_desc(ptr, &peval->shader_inputs, base_effect);
+ if (FAILED(hr))
+ {
+ FIXME("Could not get shader constant table, hr %#x.\n", hr);
+ goto err_out;
+ }
+ update_table_sizes_consts(peval->pres.regs.table_sizes, &peval->shader_inputs);
+ ptr++;
+ ptr = find_bytecode_comment(ptr, FOURCC_PRES);
+ if (ptr == NULL)
+ TRACE("No preshader found.\n");
+ }
+ if (ptr)
+ {
+ hr = parse_preshader(&peval->pres, ptr, base_effect);
+ if (FAILED(hr))
+ {
+ FIXME("Failed parsing preshader: byte code for analysis follows.\n");
+ dump_shader_bytecode(byte_code, byte_code_size);
+ goto err_out;
+ }
+ }
+
+ for (i = PRES_REGTAB_IMMED + 1; i < PRES_REGTAB_MAX; i++)
+ {
+ TRACE("table_sizes[%u] %u\n", i, peval->pres.regs.table_sizes[i]);
+ if (FAILED(regstore_alloc_table(&peval->pres.regs, i)))
+ {
+ hr = E_OUTOFMEMORY;
+ goto err_out;
+ }
+ }
+
+ if (TRACE_ON(d3dx))
+ {
+ dump_shader_bytecode(byte_code, byte_code_size);
+ dump_preshader(&peval->pres);
+ if (peval->peval_type == PEVAL_TYPE_SHADER)
+ {
+ TRACE("// Shader registers:\n");
+ dump_registers(&peval->shader_inputs);
+ }
+ }
+ *peval_out = peval;
+ return D3D_OK;
+
+err_out:
+ FIXME("Error creating parameter evaluator.\n");
+ d3dx_free_param_eval(peval);
+ *peval_out = NULL;
+ return hr;
+}
+
+static void d3dx_free_const_tab(struct d3dx_const_tab *ctab)
+{
+ if (ctab->inputs)
+ HeapFree(GetProcessHeap(), 0, ctab->inputs);
+ if (ctab->inputs_param)
+ HeapFree(GetProcessHeap(), 0, ctab->inputs_param);
+ if (ctab->ctab)
+ ID3DXConstantTable_Release(ctab->ctab);
+}
+
+static void d3dx_free_preshader(struct d3dx_preshader *pres)
+{
+ if (pres->ins)
+ HeapFree(GetProcessHeap(), 0, pres->ins);
+
+ regstore_free_tables(&pres->regs);
+ d3dx_free_const_tab(&pres->inputs);
+}
+
+void d3dx_free_param_eval(struct d3dx_param_eval *peval)
+{
+ TRACE("peval %p.\n", peval);
+
+ if (!peval)
+ return ;
+
+ d3dx_free_preshader(&peval->pres);
+ d3dx_free_const_tab(&peval->shader_inputs);
+ HeapFree(GetProcessHeap(), 0, peval);
+}
+
--
2.5.0
More information about the wine-patches
mailing list