34#define INT_FLOAT_MULTI 255.0f
35#define INT_FLOAT_MULTI_INVERSE (1/INT_FLOAT_MULTI)
40#define PARAMETER_FLAG_SHARED 1
42#define INITIAL_POOL_SIZE 16
43#define INITIAL_PARAM_BLOCK_SIZE 1024
208#define INITIAL_SHARED_DATA_SIZE 4
447 WARN(
"Skipping %u unknown DWORDs:\n",
count);
451 WARN(
"\t0x%08x\n",
d);
607 if (!
param->element_count)
618 TRACE(
"Free parameter %p, name %s, type %s, element %#x, child %#x.\n",
param,
param->name,
621 if (
param->param_eval)
646 if (
param->annotations)
650 for (
i = 0;
i <
param->annotation_count; ++
i)
667 if (
pass->annotations)
669 for (
i = 0;
i <
pass->annotation_count; ++
i)
677 for (
i = 0;
i <
pass->state_count; ++
i)
691 TRACE(
"Free technique %p\n", technique);
724 return sizeof(*record) +
record->bytes;
749 ID3DXEffectPool *
pool;
765 for (
i = 0;
i <
effect->parameter_count; ++
i)
772 for (
i = 0;
i <
effect->technique_count; ++
i)
779 for (
i = 0;
i <
effect->object_count; ++
i)
791 IUnknown_Release(
effect->manager);
801 for (
i = 0;
i < 4; ++
i)
803 if (i < param->columns)
814 for (
i = 0;
i <
param->columns; ++
i)
822 for (
i = 0;
i < 4; ++
i)
824 for (
k = 0;
k < 4; ++
k)
828 if ((i < param->rows) && (
k <
param->columns))
842 if (
param->columns == 4)
856 for (
k = 0;
k <
param->columns; ++
k)
868 for (
k = 0;
k <
param->columns; ++
k)
882 ERR(
"Out of memory.\n");
885 strcpy(*param_data,
string);
909 if (new_texture == old_texture)
913 IUnknown_AddRef(new_texture);
915 IUnknown_Release(old_texture);
969 TRACE(
"Returning parameter %p\n", temp_parameter);
970 return temp_parameter;
973 FIXME(
"Unhandled case \"%c\"\n", *--part);
978 TRACE(
"Parameter not found\n");
998 temp_parameter = &annotations[
i];
1002 TRACE(
"Returning annotation %p\n", temp_parameter);
1003 return temp_parameter;
1016 FIXME(
"Unhandled case \"%c\"\n", *--part);
1022 TRACE(
"Annotation not found\n");
1030 unsigned int name_len, param_name_len;
1033 unsigned int full_name_size;
1052 full_name_size = name_len + param_name_len + 2;
1057 ERR(
"Out of memory.\n");
1068 full_name[param_name_len] =
'.';
1069 memcpy(full_name + param_name_len + 1,
name, name_len);
1070 full_name[param_name_len + 1 + name_len] = 0;
1086 temp_parameter = ¶meter->
members[
i];
1090 TRACE(
"Returning parameter %p\n", temp_parameter);
1091 return temp_parameter;
1104 FIXME(
"Unhandled case \"%c\"\n", *--part);
1110 TRACE(
"Parameter not found\n");
1116 return (0xfeff0000 | ((
major) << 8) | (
minor));
1121 BOOL update_all,
BOOL *param_dirty)
1125 *param_value =
NULL;
1127 *param_dirty =
FALSE;
1129 switch (
state->type)
1137 *param_value =
param->data;
1141 unsigned int array_idx;
1143 {
"",
NULL,
NULL,
NULL,
NULL,
D3DXPC_SCALAR,
D3DXPT_INT, 1, 1, 0, 0, 0,
sizeof(array_idx)};
1147 if (!
param->param_eval)
1149 FIXME(
"Preshader structure is null.\n");
1161 array_idx =
state->index;
1163 ref_param =
state->referenced_param;
1164 TRACE(
"Array index %u, stored array index %u, element_count %u.\n", array_idx,
state->index,
1168 if (array_idx == ~0
u)
1170 WARN(
"Array index is -1, setting to 0.\n");
1176 WARN(
"Computed array index %u is larger than array size %u.\n",
1180 selected_param = &ref_param->
members[array_idx];
1182 state->index = array_idx;
1184 *param_value = selected_param->
data;
1185 *out_param = selected_param;
1189 if (
param->param_eval)
1192 *param_value =
param->data;
1198 *param_dirty =
TRUE;
1206 FIXME(
"No preshader for FXLC parameter.\n");
1223 return pass->annotation_count;
1248 FIXME(
"Functions are not handled, yet!\n");
1257 unsigned int member_count;
1262 member_count =
param->element_count ?
param->element_count :
param->member_count;
1263 for (
i = 0;
i < member_count; ++
i)
1285 unsigned int new_size, alloc_size;
1291 if (new_size >
block->size)
1303 ERR(
"Out of memory.\n");
1309 block->size = alloc_size;
1310 block->buffer = new_alloc;
1314 block->offset = new_size;
1376 TRACE(
"%s (%.8e %.8e %.8e %.8e).\n", light_tbl[
op].
name,
c.r,
c.g,
c.b,
c.a);
1385 TRACE(
"%s (%.8e %.8e %.8e).\n", light_tbl[
op].
name,
v.x,
v.y,
v.z);
1397 float v = *(
float *)
value;
1403 WARN(
"Unknown light parameter %u.\n",
op);
1428 float v = *(
float *)
value;
1441 TRACE(
"%s, value (%.8e %.8e %.8e %.8e).\n", material_tbl[
op].
name,
c.r,
c.g,
c.b,
c.a);
1446 WARN(
"Unknown material parameter %u.\n",
op);
1471 unsigned int element_count;
1472 void *
buffer = value_ptr;
1477 element_count =
param->bytes / const_tbl[
op].elem_size;
1478 TRACE(
"%s, index %u, element_count %u.\n", const_tbl[
op].
name,
index, element_count);
1479 if (
param->type != const_tbl[
op].type)
1481 FIXME(
"Unexpected param type %u.\n",
param->type);
1485 if (
param->bytes % const_tbl[
op].elem_size || element_count > 1)
1487 unsigned int param_data_size;
1491 if (
param->bytes % const_tbl[
op].elem_size)
1493 if (element_count > 1)
1495 WARN(
"Setting %u elements.\n", element_count);
1499 ERR(
"Out of memory.\n");
1502 is_heap_buffer =
TRUE;
1509 param_data_size =
min(
param->bytes, const_tbl[
op].elem_size);
1512 const_tbl[
op].elem_size * element_count - param_data_size);
1555 unsigned int parameters_count;
1558 if (!
param->param_eval)
1560 FIXME(
"param_eval structure is null.\n");
1564 param->param_eval, update_all)))
1566 params =
param->param_eval->shader_inputs.inputs_param;
1567 cdesc =
param->param_eval->shader_inputs.inputs;
1568 parameters_count =
param->param_eval->shader_inputs.input_count;
1570 for (
i = 0;
i < parameters_count; ++
i)
1575 unsigned int sampler_idx;
1577 for (sampler_idx = 0; sampler_idx < cdesc[
i].
RegisterCount; ++sampler_idx)
1581 cdesc[
i].RegisterIndex,
sampler->state_count);
1606 update_all, ¶m_dirty)))
1613 WARN(
"Returning D3D_OK on out of bounds array access.\n");
1619 if (!(update_all || param_dirty
1638 unit = parent_index == ~0
u ?
state->index : parent_index;
1640 *(IDirect3DBaseTexture9 **)param_value);
1641 return SET_D3D_STATE(effect, SetTexture,
unit, *(IDirect3DBaseTexture9 **)param_value);
1668 sampler = parent_index == ~0
u ?
state->index : parent_index;
1671 *(
DWORD *)param_value);
1674 TRACE(
"%s, shader %p.\n",
state_table[
state->operation].name, *(IDirect3DVertexShader9 **)param_value);
1675 if ((update_all || param_dirty)
1677 *(IDirect3DVertexShader9 **)param_value)))
1678 ERR(
"Could not set vertex shader, hr %#x.\n",
hr);
1679 else if (*(IDirect3DVertexShader9 **)param_value)
1683 TRACE(
"%s, shader %p.\n",
state_table[
state->operation].name, *(IDirect3DPixelShader9 **)param_value);
1684 if ((update_all || param_dirty)
1686 *(IDirect3DPixelShader9 **)param_value)))
1687 ERR(
"Could not set pixel shader, hr %#x.\n",
hr);
1688 else if (*(IDirect3DPixelShader9 **)param_value)
1718 return SET_D3D_STATE(effect, SetNPatchMode, *(
float *)param_value);
1723 param, param_value);
1738 TRACE(
"effect %p, pass %p, state_count %u.\n", effect,
pass,
pass->state_count);
1741 for (
i = 0;
i <
pass->state_count; ++
i)
1745 WARN(
"Error applying state, hr %#x.\n",
hr);
1757 WARN(
"Error setting light, hr %#x.\n",
hr);
1767 WARN(
"Error setting material, hr %#x.\n",
hr);
1772 pass->update_version = new_update_version;
1778 unsigned char *member_data =
data;
1786 member_data +=
param->members[
i].bytes;
1819 unsigned int i, free_entry_index;
1820 unsigned int new_size, new_count;
1825 free_entry_index =
pool->size;
1826 for (
i = 0;
i <
pool->size; ++
i)
1828 if (!
pool->shared_data[
i].count)
1829 free_entry_index =
i;
1833 if (
i ==
pool->size)
1835 i = free_entry_index;
1836 if (
i ==
pool->size)
1844 sizeof(*
pool->shared_data) * new_size);
1847 ERR(
"Out of memory.\n");
1853 new_size =
pool->size * 2;
1855 sizeof(*
pool->shared_data) * new_size);
1858 ERR(
"Out of memory.\n");
1861 if (new_alloc !=
pool->shared_data)
1865 for (
j = 0;
j <
pool->size; ++
j)
1866 for (
k = 0;
k < new_alloc[
j].
count; ++
k)
1870 pool->shared_data = new_alloc;
1871 pool->size = new_size;
1873 pool->shared_data[
i].data =
param->param.data;
1879 new_count = ++
pool->shared_data[
i].count;
1880 if (new_count >=
pool->shared_data[
i].size)
1882 if (!
pool->shared_data[
i].size)
1890 new_size =
pool->shared_data[
i].size * 2;
1892 pool->shared_data[
i].parameters,
1893 sizeof(*
pool->shared_data[
i].parameters) * new_size);
1895 pool->shared_data[
i].size = new_size;
1899 pool->shared_data[
i].parameters[new_count - 1] =
param;
1915 unsigned int new_count;
1919 new_count = --
param->shared_data->count;
1921 TRACE(
"param %p, param->shared_data %p, new_count %d.\n",
param,
param->shared_data, new_count);
1927 for (
i = 0;
i < new_count; ++
i)
1932 &
param->shared_data->parameters[
i + 1],
1933 sizeof(
param->shared_data->parameters[
i]) * (new_count -
i));
1943 param->shared_data->size = 0;
1968 iface->lpVtbl->AddRef(iface);
1992 TRACE(
"%p decreasing refcount to %u.\n", effect, refcount);
2005 FIXME(
"iface %p, desc %p partial stub.\n", iface,
desc);
2009 WARN(
"Invalid argument specified.\n");
2015 desc->Functions = 0;
2028 TRACE(
"iface %p, parameter %p, desc %p.\n", iface, parameter,
desc);
2032 WARN(
"Invalid argument specified.\n");
2045 desc->StructMembers =
param->member_count;
2058 TRACE(
"iface %p, technique %p, desc %p.\n", iface, technique,
desc);
2062 WARN(
"Invalid argument specified.\n");
2083 WARN(
"Invalid argument specified.\n");
2088 desc->Annotations =
pass->annotation_count;
2090 desc->pVertexShaderFunction =
NULL;
2096 for (
i = 0;
i <
pass->state_count; ++
i)
2110 FALSE, ¶m_dirty)))
2115 desc->pVertexShaderFunction =
data;
2137 TRACE(
"iface %p, parameter %p, index %u.\n", iface, parameter,
index);
2141 if (index < effect->parameter_count)
2156 WARN(
"Parameter not found.\n");
2203 TRACE(
"Returning parameter %p\n", temp_param);
2211 TRACE(
"Returning parameter %p\n", temp_param);
2218 for (
i = 0;
i <
param->member_count; ++
i)
2226 TRACE(
"Returning parameter %p\n", temp_param);
2234 TRACE(
"Returning parameter %p\n", temp_param);
2240 WARN(
"Parameter not found.\n");
2250 TRACE(
"iface %p, parameter %p, index %u.\n", iface, parameter,
index);
2254 if (index < effect->parameter_count)
2269 WARN(
"Parameter not found.\n");
2278 TRACE(
"iface %p, index %u.\n", iface,
index);
2282 WARN(
"Invalid argument specified.\n");
2301 TRACE(
"Returning technique %p\n",
t);
2305 WARN(
"Technique not found.\n");
2315 TRACE(
"iface %p, technique %p, index %u.\n", iface, technique,
index);
2323 WARN(
"Pass not found.\n");
2351 WARN(
"Pass not found.\n");
2358 FIXME(
"iface %p, index %u stub.\n", iface,
index);
2374 unsigned int annotation_count;
2376 TRACE(
"iface %p, object %p, index %u.\n", iface,
object,
index);
2380 if (
index < annotation_count)
2382 TRACE(
"Returning parameter %p\n", &annotations[
index]);
2386 WARN(
"Annotation not found.\n");
2397 unsigned int annotation_count;
2403 WARN(
"Invalid argument specified\n");
2416 WARN(
"Annotation not found.\n");
2427 TRACE(
"iface %p, parameter %p, data %p, bytes %u.\n", iface, parameter,
data,
bytes);
2431 WARN(
"Invalid parameter %p specified.\n", parameter);
2436 WARN(
"Parameter is a sampler, returning E_FAIL.\n");
2443 WARN(
"Invalid argument specified.\n");
2453 TRACE(
"iface %p, parameter %p, data %p, bytes %u.\n", iface, parameter,
data,
bytes);
2457 WARN(
"Invalid parameter %p specified.\n", parameter);
2462 WARN(
"Parameter is a sampler, returning E_FAIL.\n");
2470 switch (
param->type)
2489 for (
i = 0;
i < (
param->element_count ?
param->element_count : 1); ++
i)
2493 IUnknown_AddRef(unk);
2508 WARN(
"Parameter not found.\n");
2518 TRACE(
"iface %p, parameter %p, b %#x.\n", iface, parameter,
b);
2527 WARN(
"Parameter not found.\n");
2537 TRACE(
"iface %p, parameter %p, b %p.\n", iface, parameter,
b);
2542 TRACE(
"Returning %s\n", *
b ?
"TRUE" :
"FALSE");
2546 WARN(
"Parameter not found.\n");
2557 TRACE(
"iface %p, parameter %p, b %p, count %u.\n", iface, parameter,
b,
count);
2565 switch (
param->class)
2588 WARN(
"Parameter not found.\n");
2598 TRACE(
"iface %p, parameter %p, b %p, count %u.\n", iface, parameter,
b,
count);
2614 WARN(
"Parameter not found.\n");
2624 TRACE(
"iface %p, parameter %p, n %d.\n", iface, parameter,
n);
2645 TRACE(
"Vector fixup.\n");
2660 WARN(
"Parameter not found.\n");
2670 TRACE(
"iface %p, parameter %p, n %p.\n", iface, parameter,
n);
2677 TRACE(
"Returning %d.\n", *
n);
2685 TRACE(
"Vector fixup.\n");
2693 TRACE(
"Returning %d.\n", *
n);
2698 WARN(
"Parameter not found.\n");
2709 TRACE(
"iface %p, parameter %p, n %p, count %u.\n", iface, parameter,
n,
count);
2717 switch (
param->class)
2737 WARN(
"Parameter not found.\n");
2747 TRACE(
"iface %p, parameter %p, n %p, count %u.\n", iface, parameter,
n,
count);
2761 WARN(
"Parameter not found.\n");
2771 TRACE(
"iface %p, parameter %p, f %.8e.\n", iface, parameter,
f);
2783 WARN(
"Parameter not found.\n");
2793 TRACE(
"iface %p, parameter %p, f %p.\n", iface, parameter,
f);
2798 TRACE(
"Returning %f.\n", *
f);
2802 WARN(
"Parameter not found.\n");
2814 TRACE(
"iface %p, parameter %p, f %p, count %u.\n", iface, parameter,
f,
count);
2822 switch (
param->class)
2842 WARN(
"Parameter not found.\n");
2852 TRACE(
"iface %p, parameter %p, f %p, count %u.\n", iface, parameter,
f,
count);
2866 WARN(
"Parameter not found.\n");
2876 TRACE(
"iface %p, parameter %p, vector %p.\n", iface, parameter,
vector);
2882 switch (
param->class)
2890 TRACE(
"INT fixup.\n");
2920 WARN(
"Parameter not found.\n");
2930 TRACE(
"iface %p, parameter %p, vector %p.\n", iface, parameter,
vector);
2936 switch (
param->class)
2942 TRACE(
"INT fixup.\n");
2963 WARN(
"Parameter not found.\n");
2974 TRACE(
"iface %p, parameter %p, vector %p, count %u.\n", iface, parameter,
vector,
count);
2983 switch (
param->class)
2990 if (
param->columns == 4)
2998 param->columns *
sizeof(
float));
3020 WARN(
"Parameter not found.\n");
3031 TRACE(
"iface %p, parameter %p, vector %p, count %u.\n", iface, parameter,
vector,
count);
3042 switch (
param->class)
3061 WARN(
"Parameter not found.\n");
3071 TRACE(
"iface %p, parameter %p, matrix %p.\n", iface, parameter,
matrix);
3077 switch (
param->class)
3096 WARN(
"Parameter not found.\n");
3106 TRACE(
"iface %p, parameter %p, matrix %p.\n", iface, parameter,
matrix);
3112 switch (
param->class)
3130 WARN(
"Parameter not found.\n");
3141 TRACE(
"iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter,
matrix,
count);
3150 switch (
param->class)
3154 *
param->columns *
sizeof(
float),
TRUE);
3174 WARN(
"Parameter not found.\n");
3185 TRACE(
"iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter,
matrix,
count);
3196 switch (
param->class)
3215 WARN(
"Parameter not found.\n");
3226 TRACE(
"iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter,
matrix,
count);
3233 switch (
param->class)
3237 *
param->columns *
sizeof(
float),
TRUE);
3241 *
param->columns *
sizeof(
float));
3256 WARN(
"Parameter not found.\n");
3267 TRACE(
"iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter,
matrix,
count);
3278 switch (
param->class)
3296 WARN(
"Parameter not found.\n");
3307 TRACE(
"iface %p, parameter %p, matrix %p.\n", iface, parameter,
matrix);
3313 switch (
param->class)
3332 WARN(
"Parameter not found.\n");
3343 TRACE(
"iface %p, parameter %p, matrix %p.\n", iface, parameter,
matrix);
3349 switch (
param->class)
3370 WARN(
"Parameter not found.\n");
3381 TRACE(
"iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter,
matrix,
count);
3390 switch (
param->class)
3394 *
param->columns *
sizeof(
float),
TRUE);
3398 +
i *
param->rows *
param->columns *
sizeof(
float));
3414 WARN(
"Parameter not found.\n");
3425 TRACE(
"iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter,
matrix,
count);
3436 switch (
param->class)
3455 WARN(
"Parameter not found.\n");
3466 TRACE(
"iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter,
matrix,
count);
3473 switch (
param->class)
3477 *
param->columns *
sizeof(
float),
TRUE);
3481 +
i *
param->rows *
param->columns *
sizeof(
float));
3496 WARN(
"Parameter not found.\n");
3507 TRACE(
"iface %p, parameter %p, matrix %p, count %u.\n", iface, parameter,
matrix,
count);
3518 switch (
param->class)
3536 WARN(
"Parameter not found.\n");
3546 TRACE(
"iface %p, parameter %p, string %s.\n", iface, parameter,
debugstr_a(
string));
3551 WARN(
"Parameter not found.\n");
3561 TRACE(
"iface %p, parameter %p, string %p.\n", iface, parameter,
string);
3565 *
string = *(
const char **)
param->data;
3570 WARN(
"Parameter not found.\n");
3576 IDirect3DBaseTexture9 *
texture)
3581 TRACE(
"iface %p, parameter %p, texture %p.\n", iface, parameter,
texture);
3589 sizeof(
void *),
texture != *(IDirect3DBaseTexture9 **)
param->data);
3590 IDirect3DBaseTexture9 *old_texture = *
data;
3605 WARN(
"Parameter not found.\n");
3611 IDirect3DBaseTexture9 **
texture)
3616 TRACE(
"iface %p, parameter %p, texture %p.\n", iface, parameter,
texture);
3630 WARN(
"Parameter not found.\n");
3636 IDirect3DPixelShader9 **
shader)
3641 TRACE(
"iface %p, parameter %p, shader %p.\n", iface, parameter,
shader);
3645 if ((*
shader = *(IDirect3DPixelShader9 **)
param->data))
3651 WARN(
"Parameter not found.\n");
3657 IDirect3DVertexShader9 **
shader)
3662 TRACE(
"iface %p, parameter %p, shader %p.\n", iface, parameter,
shader);
3666 if ((*
shader = *(IDirect3DVertexShader9 **)
param->data))
3672 WARN(
"Parameter not found.\n");
3679 FIXME(
"iface %p, parameter %p, start %u, end %u stub.\n", iface, parameter,
start,
end);
3689 TRACE(
"iface %p, pool %p.\n", effect,
pool);
3693 WARN(
"Invalid argument supplied.\n");
3700 *
pool = &effect->
pool->ID3DXEffectPool_iface;
3714 TRACE(
"iface %p, technique %p\n", iface, technique);
3719 TRACE(
"Technique %p\n", tech);
3723 WARN(
"Technique not found.\n");
3744 FIXME(
"iface %p, technique %p semi-stub.\n", iface, technique);
3755 for (
j = 0;
j <
pass->state_count; ++
j)
3768 FALSE, ¶m_dirty)))
3791 TRACE(
"iface %p, technique %p, next_technique %p.\n", iface, technique, next_technique);
3801 if (tech == prev_tech)
3834 unsigned int i, param_count;
3840 param_count =
param_eval->shader_inputs.input_count;
3841 for (
i = 0;
i < param_count; ++
i)
3848 param_count =
param_eval->pres.inputs.input_count;
3849 for (
i = 0;
i < param_count; ++
i)
3889 unsigned int sampler_idx;
3890 unsigned int samplers_count =
max(
param->element_count, 1);
3892 for (sampler_idx = 0; sampler_idx < samplers_count; ++sampler_idx)
3904 member_count =
param->element_count ?
param->element_count :
param->member_count;
3905 for (
i = 0;
i < member_count; ++
i)
3919 if (!tech || !
param)
3925 for (
j = 0;
j <
pass->state_count; ++
j)
3941 TRACE(
"iface %p, parameter %p, technique %p.\n", iface, parameter, technique);
3959 WARN(
"Invalid flags (%#x) specified.\n",
flags);
3963 TRACE(
"State capturing disabled.\n");
3972 ID3DXEffectStateManager *manager;
3977 ERR(
"BeginStateBlock failed, hr %#x.\n",
hr);
3981 ERR(
"EndStateBlock failed, hr %#x.\n",
hr);
3985 ERR(
"StateBlock Capture failed, hr %#x.\n",
hr);
3996 WARN(
"Invalid argument supplied.\n");
4006 TRACE(
"iface %p, pass %u\n", effect,
pass);
4020 WARN(
"Invalid argument supplied.\n");
4029 TRACE(
"iface %p.\n", iface);
4033 WARN(
"Called without an active pass.\n");
4045 if (
This->active_pass)
4051 WARN(
"Invalid call.\n");
4061 TRACE(
"iface %p.\n", iface);
4068 TRACE(
"State restoring disabled.\n");
4077 ERR(
"State block apply failed, hr %#x.\n",
hr);
4080 ERR(
"No saved state.\n");
4096 WARN(
"Invalid argument supplied.\n");
4111 struct IDirect3DVolumeTexture9 *volume_texture;
4112 struct IDirect3DCubeTexture9 *cube_texture;
4113 struct IDirect3DTexture9 *
texture;
4119 switch (
param->type)
4132 volume_texture = *(IDirect3DVolumeTexture9 **)
param->data;
4133 if (!volume_texture)
4140 cube_texture = *(IDirect3DCubeTexture9 **)
param->data;
4161 TRACE(
"iface %p.\n", iface);
4185 if (
This->manager) IUnknown_Release(
This->manager);
4200 WARN(
"Invalid argument supplied.\n");
4204 if (
This->manager) IUnknown_AddRef(
This->manager);
4214 TRACE(
"iface %p.\n", iface);
4218 WARN(
"Parameter block is already started.\n");
4235 TRACE(
"iface %p.\n", iface);
4237 if (!
effect->current_parameter_block)
4239 WARN(
"No active parameter block.\n");
4257 TRACE(
"iface %p, parameter_block %p.\n", iface, parameter_block);
4273#if D3DX_SDK_VERSION >= 26
4280 TRACE(
"iface %p, parameter_block %p.\n", iface, parameter_block);
4295 WARN(
"Block is not found in issued block list, not freeing memory.\n");
4301 ID3DXEffect **new_effect)
4305 FIXME(
"iface %p, device %p, new_effect %p stub.\n", effect,
device, new_effect);
4316 iface->lpVtbl->AddRef(iface);
4317 *new_effect = iface;
4321#if D3DX_SDK_VERSION >= 27
4325 FIXME(
"iface %p, parameter %p, data %p, byte_offset %u, bytes %u stub!\n",
4326 iface, parameter,
data, byte_offset,
bytes);
4413#if D3DX_SDK_VERSION >= 26
4414 d3dx_effect_DeleteParameterBlock,
4417#if D3DX_SDK_VERSION >= 27
4418 d3dx_effect_SetRawValue
4435 iface->lpVtbl->AddRef(iface);
4451 TRACE(
"%p increasing refcount to %u.\n", iface, refcount);
4461 TRACE(
"%p decreasing refcount to %u.\n", iface, refcount);
4474 FIXME(
"iface %p, desc %p stub!\n", iface,
desc);
4482 FIXME(
"iface %p, parameter %p, desc %p stub!\n", iface, parameter,
desc);
4490 FIXME(
"iface %p, technique %p, desc %p stub!\n", iface, technique,
desc);
4498 FIXME(
"iface %p, pass %p, desc %p stub!\n", iface,
pass,
desc);
4514 FIXME(
"iface %p, parameter %p, index %u stub!\n", iface, parameter,
index);
4530 FIXME(
"iface %p, parameter %p, semantic %s stub!\n", iface, parameter,
debugstr_a(semantic));
4538 FIXME(
"iface %p, parameter %p, index %u stub!\n", iface, parameter,
index);
4545 FIXME(
"iface %p, index %u stub!\n", iface,
index);
4559 FIXME(
"iface %p, technique %p, index %u stub!\n", iface, technique,
index);
4574 FIXME(
"iface %p, index %u stub!\n", iface,
index);
4589 FIXME(
"iface %p, object %p, index %u stub!\n", iface,
object,
index);
4605 FIXME(
"iface %p, parameter %p, data %p, bytes %u stub!\n", iface, parameter,
data,
bytes);
4613 FIXME(
"iface %p, parameter %p, data %p, bytes %u stub!\n", iface, parameter,
data,
bytes);
4620 FIXME(
"iface %p, parameter %p, b %#x stub!\n", iface, parameter,
b);
4627 FIXME(
"iface %p, parameter %p, b %p stub!\n", iface, parameter,
b);
4635 FIXME(
"iface %p, parameter %p, b %p, count %u stub!\n", iface, parameter,
b,
count);
4643 FIXME(
"iface %p, parameter %p, b %p, count %u stub!\n", iface, parameter,
b,
count);
4650 FIXME(
"iface %p, parameter %p, n %d stub!\n", iface, parameter,
n);
4657 FIXME(
"iface %p, parameter %p, n %p stub!\n", iface, parameter,
n);
4665 FIXME(
"iface %p, parameter %p, n %p, count %u stub!\n", iface, parameter,
n,
count);
4673 FIXME(
"iface %p, parameter %p, n %p, count %u stub!\n", iface, parameter,
n,
count);
4680 FIXME(
"iface %p, parameter %p, f %.8e stub!\n", iface, parameter,
f);
4687 FIXME(
"iface %p, parameter %p, f %p stub!\n", iface, parameter,
f);
4695 FIXME(
"iface %p, parameter %p, f %p, count %u stub!\n", iface, parameter,
f,
count);
4703 FIXME(
"iface %p, parameter %p, f %p, count %u stub!\n", iface, parameter,
f,
count);
4711 FIXME(
"iface %p, parameter %p, vector %p stub!\n", iface, parameter,
vector);
4719 FIXME(
"iface %p, parameter %p, vector %p stub!\n", iface, parameter,
vector);
4727 FIXME(
"iface %p, parameter %p, vector %p, count %u stub!\n", iface, parameter,
vector,
count);
4735 FIXME(
"iface %p, parameter %p, vector %p, count %u stub!\n", iface, parameter,
vector,
count);
4743 FIXME(
"iface %p, parameter %p, matrix %p stub!\n", iface, parameter,
matrix);
4751 FIXME(
"iface %p, parameter %p, matrix %p stub!\n", iface, parameter,
matrix);
4759 FIXME(
"iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter,
matrix,
count);
4767 FIXME(
"iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter,
matrix,
count);
4775 FIXME(
"iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter,
matrix,
count);
4783 FIXME(
"iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter,
matrix,
count);
4791 FIXME(
"iface %p, parameter %p, matrix %p stub!\n", iface, parameter,
matrix);
4799 FIXME(
"iface %p, parameter %p, matrix %p stub!\n", iface, parameter,
matrix);
4807 FIXME(
"iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter,
matrix,
count);
4815 FIXME(
"iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter,
matrix,
count);
4823 FIXME(
"iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter,
matrix,
count);
4831 FIXME(
"iface %p, parameter %p, matrix %p, count %u stub!\n", iface, parameter,
matrix,
count);
4839 FIXME(
"iface %p, parameter %p, string %s stub!\n", iface, parameter,
debugstr_a(
string));
4847 FIXME(
"iface %p, parameter %p, string %p stub!\n", iface, parameter,
string);
4855 FIXME(
"iface %p, parameter %p, texture %p stub!\n", iface, parameter,
texture);
4863 FIXME(
"iface %p, parameter %p, texture %p stub!\n", iface, parameter,
texture);
4871 FIXME(
"iface %p, parameter %p, shader %p stub!\n", iface, parameter,
shader);
4879 FIXME(
"iface %p, parameter %p, shader %p stub!\n", iface, parameter,
shader);
4887 FIXME(
"iface %p, parameter %p, start %u, end %u stub!\n", iface, parameter,
start,
end);
4895 FIXME(
"iface %p, parameter %p, literal %#x stub!\n", iface, parameter, literal);
4902 FIXME(
"iface %p, parameter %p, literal %p stub!\n", iface, parameter, literal);
4910 FIXME(
"iface %p, flags %#x, effect %p, error_msgs %p stub!\n", iface,
flags, effect, error_msgs);
4917 ID3DXConstantTable **constant_table)
4919 FIXME(
"iface %p, function %p, target %s, flags %#x, shader %p, error_msgs %p, constant_table %p stub!\n",
5005 ERR(
"Out of memory\n");
5014 WARN(
"Failed to parse state %u\n",
i);
5040 if (
param->element_count)
5044 for (
i = 0;
i <
param->element_count; ++
i)
5051 WARN(
"Failed to parse value %u\n",
i);
5055 old_size +=
member->bytes;
5061 switch(
param->class)
5073 for (
i = 0;
i <
param->member_count; ++
i)
5080 WARN(
"Failed to parse value %u\n",
i);
5084 old_size +=
member->bytes;
5089 switch (
param->type)
5121 WARN(
"Failed to parse sampler\n");
5157 ERR(
"Failed to allocate data memory.\n");
5161 switch(
param->class)
5184 WARN(
"Failed to parse value\n");
5207 ERR(
"Failed to allocate name memory.\n");
5224 FIXME(
"Overwriting object id %u!\n", object_id);
5226 TRACE(
"Overwriting object id 0.\n");
5229 object->data =
NULL;
5241 ERR(
"Failed to allocate object memory.\n");
5248 *
ptr += ((
object->size + 3) & ~3);
5272 TRACE(
"Adding parameter %p (%s - parent %p, element %u) to the rbtree.\n",
5277 unsigned int parent_name_len =
strlen(parent_name);
5279 unsigned int part_str_len;
5286 part_str_len =
strlen(part_str);
5295 len = parent_name_len + part_str_len + name_len + 1;
5299 ERR(
"Out of memory.\n");
5303 memcpy(
param->full_name, parent_name, parent_name_len);
5304 memcpy(
param->full_name + parent_name_len, part_str, part_str_len);
5305 memcpy(
param->full_name + parent_name_len + part_str_len,
param->name, name_len);
5314 ERR(
"Out of memory.\n");
5320 TRACE(
"Full name is %s.\n",
param->full_name);
5324 for (
i = 0;
i <
param->top_level_param->annotation_count; ++
i)
5327 if (
param->element_count)
5328 for (
i = 0;
i <
param->element_count; ++
i)
5331 for (
i = 0;
i <
param->member_count; ++
i)
5357 WARN(
"Failed to parse name\n");
5366 WARN(
"Failed to parse semantic\n");
5371 TRACE(
"Elements: %u\n",
param->element_count);
5373 switch (
param->class)
5405 switch (
param->type)
5415 param->bytes =
sizeof(
void *);
5444 param->element_count = 0;
5451 if (
param->element_count)
5453 unsigned int param_bytes = 0;
5454 const char *save_ptr = *
ptr;
5457 if (!
param->members)
5459 ERR(
"Out of memory\n");
5464 for (
i = 0;
i <
param->element_count; ++
i)
5472 WARN(
"Failed to parse member %u\n",
i);
5476 param_bytes +=
param->members[
i].bytes;
5479 param->bytes = param_bytes;
5481 else if (
param->member_count)
5484 if (!
param->members)
5486 ERR(
"Out of memory\n");
5491 for (
i = 0;
i <
param->member_count; ++
i)
5497 WARN(
"Failed to parse member %u\n",
i);
5544 WARN(
"Failed to parse type definition\n");
5553 WARN(
"Failed to parse value\n");
5575 WARN(
"Unknown state operation %u.\n",
state->operation);
5590 WARN(
"Failed to parse type definition\n");
5599 WARN(
"Failed to parse value\n");
5605 &&
param->bytes <
sizeof(
void *))
5609 FIXME(
"Unexpected parameter for object, param->type %#x, param->class %#x, *param->data %#x.\n",
5618 ERR(
"Out of memory.\n");
5622 memset(new_data, 0,
sizeof(
void *));
5623 param->data = new_data;
5624 param->bytes =
sizeof(
void *);
5655 TRACE(
"Annotation count: %u.\n",
param->annotation_count);
5660 WARN(
"Failed to parse type definition.\n");
5667 WARN(
"Failed to parse value.\n");
5671 if (
param->annotation_count)
5674 sizeof(*
param->annotations) *
param->annotation_count);
5675 if (!
param->annotations)
5677 ERR(
"Out of memory.\n");
5682 for (
i = 0;
i <
param->annotation_count; ++
i)
5688 WARN(
"Failed to parse annotation.\n");
5698 if (
param->annotations)
5700 for (
i = 0;
i <
param->annotation_count; ++
i)
5723 WARN(
"Failed to parse name\n");
5728 TRACE(
"Annotation count: %u\n",
pass->annotation_count);
5731 TRACE(
"State count: %u\n",
pass->state_count);
5733 if (
pass->annotation_count)
5736 sizeof(*
pass->annotations) *
pass->annotation_count);
5737 if (!
pass->annotations)
5739 ERR(
"Out of memory\n");
5744 for (
i = 0;
i <
pass->annotation_count; ++
i)
5750 WARN(
"Failed to parse annotation %u\n",
i);
5756 if (
pass->state_count)
5761 ERR(
"Out of memory\n");
5766 for (
i = 0;
i <
pass->state_count; ++
i)
5771 WARN(
"Failed to parse annotation %u\n",
i);
5778 pass->states = states;
5784 if (
pass->annotations)
5786 for (
i = 0;
i <
pass->annotation_count; ++
i)
5794 for (
i = 0;
i <
pass->state_count; ++
i)
5819 WARN(
"Failed to parse name\n");
5835 ERR(
"Out of memory\n");
5846 WARN(
"Failed to parse annotation %u\n",
i);
5858 ERR(
"Out of memory\n");
5868 WARN(
"Failed to parse pass %u\n",
i);
5907 if (*(
char **)
param->data)
5908 ERR(
"Parameter data already allocated.\n");
5910 switch (
param->type)
5914 if (!*(
char **)
param->data)
5916 ERR(
"Out of memory.\n");
5923 (IDirect3DVertexShader9 **)
param->data)))
5925 WARN(
"Failed to create vertex shader.\n");
5926 object->creation_failed =
TRUE;
5931 (IDirect3DPixelShader9 **)
param->data)))
5933 WARN(
"Failed to create pixel shader.\n");
5934 object->creation_failed =
TRUE;
5944 const char **skip_constants,
unsigned int skip_constants_count)
5949 char *
ptr =
object->data;
5952 TRACE(
"Parsing array entry selection state for parameter %p.\n",
param);
5956 if (
state->referenced_param)
5962 FIXME(
"Referenced parameter %s not found.\n",
ptr + 4);
5965 TRACE(
"Unknown DWORD: 0x%.8x.\n", *(
DWORD *)(
ptr + string_size));
5967 if (string_size %
sizeof(
DWORD))
5968 FIXME(
"Unaligned string_size %u.\n", string_size);
5979 for (
i = 0;
i <
param->element_count;
i++)
5983 FIXME(
"Unexpected member parameter type %u, expected %u.\n",
param->members[
i].type,
param->type);
5986 if (!
param->members[
i].param_eval)
5988 TRACE(
"Creating preshader for object %u.\n",
param->members[
i].object_id);
5992 skip_constants, skip_constants_count)))
6001 const char **skip_constants,
unsigned int skip_constants_count)
6003 DWORD technique_index;
6011 TRACE(
"technique_index: %u\n", technique_index);
6017 TRACE(
"element_index: %u\n", element_index);
6020 TRACE(
"state_index: %u\n", state_index);
6025 if (technique_index == 0xffffffff)
6037 if (element_index != 0xffffffff)
6041 FIXME(
"Index out of bounds: element_index %u >= element_count %u\n", element_index, parameter->
element_count);
6046 parameter = ¶meter->
members[element_index];
6050 if (state_index >=
sampler->state_count)
6052 FIXME(
"Index out of bounds: state_index %u >= state_count %u\n", state_index,
sampler->state_count);
6065 FIXME(
"Index out of bounds: technique_index %u >= technique_count %u.\n", technique_index,
6070 technique = &effect->
techniques[technique_index];
6078 if (state_index >=
pass->state_count)
6080 FIXME(
"Index out of bounds: state_index %u >= state_count %u\n", state_index,
pass->state_count);
6089 TRACE(
"Using object id %u.\n",
param->object_id);
6097 switch (
param->type)
6111 skip_constants, skip_constants_count)))
6141 if (
state->referenced_param)
6145 TRACE(
"Mapping to parameter %p, having object id %u.\n", refpar, refpar->
object_id);
6154 skip_constants, skip_constants_count)))
6161 FIXME(
"Referenced parameter %s not found.\n", (
char *)
object->data);
6183 param->top_level_param = top_level_param;
6188 DWORD start,
const char **skip_constants,
unsigned int skip_constants_count)
6191 UINT stringcount, resourcecount;
6210 ERR(
"Out of memory.\n");
6221 ERR(
"Out of memory.\n");
6232 WARN(
"Failed to parse parameter %u.\n",
i);
6245 ERR(
"Out of memory.\n");
6252 TRACE(
"Parsing technique %u.\n",
i);
6256 WARN(
"Failed to parse technique %u.\n",
i);
6263 TRACE(
"String count: %u.\n", stringcount);
6266 TRACE(
"Resource count: %u.\n", resourcecount);
6268 for (
i = 0;
i < stringcount; ++
i)
6273 TRACE(
"id: %u.\n",
id);
6285 for (
i = 0;
i < resourcecount; ++
i)
6287 TRACE(
"parse resource %u.\n",
i);
6292 WARN(
"Failed to parse resource %u.\n",
i);
6339#define INITIAL_CONST_NAMES_SIZE 4
6362 const char **
names, **new_alloc;
6372 s = skip_constants_string;
6375 if (*names_count ==
size)
6398#if D3DX_SDK_VERSION <= 36
6401 UINT compile_flags = 0;
6404 unsigned int skip_constants_count = 0;
6405 char *skip_constants_buffer =
NULL;
6406 const char **skip_constants =
NULL;
6412 TRACE(
"effect %p, device %p, data %p, data_size %lu, defines %p, include %p, eflags %#x, errors %p, "
6413 "pool %p, skip_constants %s.\n",
6438 TRACE(
"HLSL ASCII effect, trying to compile it.\n");
6440 NULL,
"fx_2_0", compile_flags,
eflags, &bytecode, &temp_errors);
6443 WARN(
"Failed to compile ASCII effect.\n");
6445 ID3D10Blob_Release(bytecode);
6448 const char *error_string = ID3D10Blob_GetBufferPointer(temp_errors);
6449 const char *string_ptr;
6451 while (*error_string)
6453 string_ptr = error_string;
6454 while (*string_ptr && *string_ptr !=
'\n' && *string_ptr !=
'\r'
6455 && string_ptr - error_string < 80)
6458 error_string = string_ptr;
6459 while (*error_string ==
'\n' || *error_string ==
'\r')
6464 *errors = temp_errors;
6465 else if (temp_errors)
6466 ID3D10Blob_Release(temp_errors);
6471 FIXME(
"No output from effect compilation.\n");
6475 *errors = temp_errors;
6476 else if (temp_errors)
6477 ID3D10Blob_Release(temp_errors);
6479 ptr = ID3D10Blob_GetBufferPointer(bytecode);
6484 if (skip_constants_string)
6487 sizeof(*skip_constants_buffer) * (
strlen(skip_constants_string) + 1));
6488 if (!skip_constants_buffer)
6491 ID3D10Blob_Release(bytecode);
6494 strcpy(skip_constants_buffer, skip_constants_string);
6500 ID3D10Blob_Release(bytecode);
6509 ID3D10Blob_Release(bytecode);
6512 FIXME(
"Failed to parse effect.\n");
6518 for (
i = 0;
i < skip_constants_count; ++
i)
6528 WARN(
"skip_constants parameter %s is used in technique %u.\n",
6538 TRACE(
"skip_constants parameter %s not found.\n",
6558 struct ID3DXEffectPool *
pool,
struct ID3DXEffect **effect,
struct ID3DXBuffer **compilation_errors)
6563 TRACE(
"device %p, srcdata %p, srcdatalen %u, defines %p, include %p,"
6564 " skip_constants %p, flags %#x, pool %p, effect %p, compilation_errors %p.\n",
6566 skip_constants,
flags,
pool, effect, compilation_errors);
6568 if (compilation_errors)
6569 *compilation_errors =
NULL;
6589 WARN(
"Failed to create effect object, hr %#x.\n",
hr);
6594 *effect = &
object->ID3DXEffect_iface;
6596 TRACE(
"Created ID3DXEffect %p\n",
object);
6603 struct ID3DXEffectPool *
pool,
struct ID3DXEffect **effect,
struct ID3DXBuffer **compilation_errors)
6605 TRACE(
"(%p, %p, %u, %p, %p, %#x, %p, %p, %p): Forwarded to D3DXCreateEffectEx\n",
device, srcdata, srcdatalen,
defines,
6615 TRACE(
"compiler %p, data %p, data_size %lu, defines %p, include %p, eflags %#x, error_messages %p.\n",
6621 FIXME(
"ID3DXEffectCompiler implementation is only a stub.\n");
6632 TRACE(
"srcdata %p, srcdatalen %u, defines %p, include %p, flags %#x, compiler %p, parse_errors %p\n",
6635 if (!srcdata || !compiler)
6637 WARN(
"Invalid arguments supplied\n");
6649 WARN(
"Failed to initialize effect compiler\n");
6654 *compiler = &
object->ID3DXEffectCompiler_iface;
6656 TRACE(
"Created ID3DXEffectCompiler %p\n",
object);
6669 iface->lpVtbl->AddRef(iface);
6693 for (
i = 0;
i <
pool->size; ++
i)
6695 if (
pool->shared_data[
i].count)
6699 WARN(
"Releasing pool with referenced parameters.\n");
6702 pool->shared_data[
i].parameters[0]->shared_data =
NULL;
6704 for (
j = 1;
j <
pool->shared_data[
i].count; ++
j)
6707 pool->shared_data[
i].parameters[
j]->shared_data =
NULL;
6760 object->refcount = 1;
6762 *
pool = &
object->ID3DXEffectPool_iface;
6769 struct ID3DXEffectPool *
pool,
struct ID3DXEffect **effect,
struct ID3DXBuffer **compilationerrors)
6777 TRACE(
"device %p, srcfile %s, defines %p, include %p, skipconstants %s, "
6778 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
6780 flags,
pool, effect, compilationerrors);
6807 effect, compilationerrors);
6817 struct ID3DXEffectPool *
pool,
struct ID3DXEffect **effect,
struct ID3DXBuffer **compilationerrors)
6823 TRACE(
"device %p, srcfile %s, defines %p, include %p, skipconstants %s, "
6824 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
6826 flags,
pool, effect, compilationerrors);
6843 struct ID3DXEffect **effect,
struct ID3DXBuffer **compilationerrors)
6845 TRACE(
"(void): relay\n");
6851 struct ID3DXEffect **effect,
struct ID3DXBuffer **compilationerrors)
6853 TRACE(
"(void): relay\n");
6865 TRACE(
"device %p, srcmodule %p, srcresource %s, defines %p, include %p, skipconstants %s, "
6866 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
6868 flags,
pool, effect, compilationerrors);
6880 skipconstants,
flags,
pool, effect, compilationerrors);
6891 TRACE(
"device %p, srcmodule %p, srcresource %s, defines %p, include %p, skipconstants %s, "
6892 "flags %#x, pool %p, effect %p, compilationerrors %p.\n",
6894 flags,
pool, effect, compilationerrors);
6906 skipconstants,
flags,
pool, effect, compilationerrors);
6911 struct ID3DXEffectPool *
pool,
struct ID3DXEffect **effect,
struct ID3DXBuffer **compilationerrors)
6913 TRACE(
"(void): relay\n");
6919 struct ID3DXEffectPool *
pool,
struct ID3DXEffect **effect,
struct ID3DXBuffer **compilationerrors)
6921 TRACE(
"(void): relay\n");
6932 TRACE(
"srcfile %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
6956 TRACE(
"srcfile %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
6974 ID3DXEffectCompiler **effectcompiler,
ID3DXBuffer **parseerrors)
6980 TRACE(
"srcmodule %p, srcresource %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
6994 ID3DXEffectCompiler **effectcompiler,
ID3DXBuffer **parseerrors)
7000 TRACE(
"srcmodule %p, srcresource %s, defines %p, include %p, flags %#x, effectcompiler %p, parseerrors %p.\n",
7014 FIXME(
"(%p, %u, %p): stub\n", effect, enable_color_code, disassembly);
int strcmp(const char *String1, const char *String2)
ACPI_SIZE strlen(const char *String)
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
char * strcpy(char *DstString, const char *SrcString)
char * strchr(const char *String, int ch)
static unsigned char bytes[4]
static void * heap_alloc(size_t len)
static BOOL heap_free(void *mem)
static void * heap_realloc(void *mem, size_t len)
#define InterlockedIncrement
#define InterlockedDecrement
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
static void list_remove(struct list_entry *entry)
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
static void list_init(struct list_entry *head)
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
HRESULT WINAPI D3DCompile(const void *data, SIZE_T data_size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, const char *target, UINT sflags, UINT eflags, ID3DBlob **shader, ID3DBlob **error_messages)
#define D3DXERR_INVALIDDATA
@ D3DRS_EMISSIVEMATERIALSOURCE
@ D3DRS_SPECULARMATERIALSOURCE
@ D3DRS_AMBIENTMATERIALSOURCE
@ D3DRS_POINTSPRITEENABLE
@ D3DRS_DEBUGMONITORTOKEN
@ D3DRS_DIFFUSEMATERIALSOURCE
@ D3DRS_INDEXEDVERTEXBLENDENABLE
@ D3DRS_MULTISAMPLEANTIALIAS
@ D3DTSS_TEXTURETRANSFORMFLAGS
#define IDirect3DTexture9_GetLevelDesc(p, a, b)
#define IDirect3DVolumeTexture9_GetLevelDesc(p, a, b)
#define IDirect3DDevice9_CreatePixelShader(p, a, b)
#define IDirect3DStateBlock9_Release(p)
#define IDirect3DVertexShader9_AddRef(p)
#define IDirect3DDevice9_EndStateBlock(p, a)
#define IDirect3DDevice9_Release(p)
#define IDirect3DBaseTexture9_Release(p)
#define IDirect3DBaseTexture9_AddRef(p)
#define IDirect3DStateBlock9_Apply(p)
#define IDirect3DDevice9_BeginStateBlock(p)
#define IDirect3DStateBlock9_Capture(p)
#define IDirect3DDevice9_AddRef(p)
#define IDirect3DDevice9_CreateVertexShader(p, a, b)
#define IDirect3DPixelShader9_AddRef(p)
@ D3DRS_ENABLEADAPTIVETESSELLATION
@ D3DRS_SEPARATEALPHABLENDENABLE
@ D3DRS_COLORWRITEENABLE2
@ D3DRS_COLORWRITEENABLE1
@ D3DRS_MINTESSELLATIONLEVEL
@ D3DRS_TWOSIDEDSTENCILMODE
@ D3DRS_COLORWRITEENABLE3
@ D3DRS_SLOPESCALEDEPTHBIAS
@ D3DRS_MAXTESSELLATIONLEVEL
@ D3DRS_ANTIALIASEDLINEENABLE
@ D3DRS_SCISSORTESTENABLE
#define D3DVERTEXTEXTURESAMPLER0
#define D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY
static SIZE_T const char const D3D_SHADER_MACRO ID3DInclude * include
static SIZE_T const char const D3D_SHADER_MACRO ID3DInclude UINT ID3DBlob ID3DBlob ** error_messages
static SIZE_T const char const D3D_SHADER_MACRO * defines
#define D3DERR_INVALIDCALL
struct ID3DXBuffer ID3DXBuffer
static BOOL is_param_type_sampler(D3DXPARAMETER_TYPE type)
static struct d3dx_top_level_parameter * top_level_parameter_from_parameter(struct d3dx_parameter *param)
static BOOL is_param_dirty(struct d3dx_parameter *param, ULONG64 update_version)
static ULONG64 next_update_version(ULONG64 *version_counter)
HRESULT d3dx_param_eval_set_shader_constants(ID3DXEffectStateManager *manager, struct IDirect3DDevice9 *device, struct d3dx_param_eval *peval, BOOL update_all) DECLSPEC_HIDDEN
HRESULT d3dx_create_param_eval(struct d3dx_effect *effect, void *byte_code, unsigned int byte_code_size, D3DXPARAMETER_TYPE type, struct d3dx_param_eval **peval, ULONG64 *version_counter, const char **skip_constants, unsigned int skip_constants_count) DECLSPEC_HIDDEN
HRESULT map_view_of_file(const WCHAR *filename, void **buffer, DWORD *length) DECLSPEC_HIDDEN
const char * debug_d3dxparameter_type(D3DXPARAMETER_TYPE t) DECLSPEC_HIDDEN
void d3dx_free_param_eval(struct d3dx_param_eval *peval) DECLSPEC_HIDDEN
static void set_number(void *outdata, D3DXPARAMETER_TYPE outtype, const void *indata, D3DXPARAMETER_TYPE intype)
HRESULT d3dx_evaluate_parameter(struct d3dx_param_eval *peval, const struct d3dx_parameter *param, void *param_value) DECLSPEC_HIDDEN
BOOL is_param_eval_input_dirty(struct d3dx_param_eval *peval, ULONG64 update_version) DECLSPEC_HIDDEN
static BOOL is_top_level_parameter(struct d3dx_parameter *param)
HRESULT load_resource_into_memory(HMODULE module, HRSRC resinfo, void **buffer, DWORD *length) DECLSPEC_HIDDEN
#define SET_D3D_STATE(base_effect, args...)
const char * debug_d3dxparameter_class(D3DXPARAMETER_CLASS c) DECLSPEC_HIDDEN
#define D3DXFX_DONOTSAVESTATE
#define D3DX_PARAMETER_ANNOTATION
#define D3DXFX_DONOTSAVESAMPLERSTATE
#define D3DXFX_NOT_CLONEABLE
#define D3DXFX_DONOTSAVESHADERSTATE
#define D3DXFX_LARGEADDRESSAWARE
#define ID3DXInclude_Close(p, a)
#define ID3DXInclude_Open(p, a, b, c, d, e)
static HRESULT d3dx_parse_state(struct d3dx_effect *effect, struct d3dx_state *state, const char *data, const char **ptr, struct d3dx_object *objects)
#define INITIAL_SHARED_DATA_SIZE
static const struct @243 state_table[]
static HRESULT d3dx_parse_effect_technique(struct d3dx_effect *effect, struct d3dx_technique *technique, const char *data, const char **ptr, struct d3dx_object *objects)
static BOOL param_on_lost_device(void *data, struct d3dx_parameter *param)
static HRESULT WINAPI d3dx_effect_GetVertexShader(ID3DXEffect *iface, D3DXHANDLE parameter, IDirect3DVertexShader9 **shader)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n)
static HRESULT WINAPI d3dx_effect_GetMatrixTransposeArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI d3dx_effect_SetMatrixTranspose(ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix)
static void param_set_magic_number(struct d3dx_parameter *param)
static HRESULT d3dx_parse_effect_annotation(struct d3dx_effect *effect, struct d3dx_parameter *anno, const char *data, const char **ptr, struct d3dx_object *objects)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixPointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count)
static HRESULT WINAPI d3dx_effect_SetMatrixArray(ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count)
static HRESULT d3dx_parse_effect_pass(struct d3dx_effect *effect, struct d3dx_pass *pass, const char *data, const char **ptr, struct d3dx_object *objects)
static HRESULT WINAPI d3dx_effect_OnLostDevice(ID3DXEffect *iface)
static HRESULT WINAPI d3dx_effect_QueryInterface(ID3DXEffect *iface, REFIID riid, void **object)
HRESULT WINAPI D3DXCreateEffectFromFileA(struct IDirect3DDevice9 *device, const char *srcfile, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
static HRESULT WINAPI d3dx_effect_SetMatrix(ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetString(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const char *string)
static BOOL walk_parameter_tree(struct d3dx_parameter *param, walk_parameter_dep_func param_func, void *data)
static ULONG64 * get_version_counter_ptr(struct d3dx_effect *effect)
static void free_top_level_parameter(struct d3dx_top_level_parameter *param)
static struct d3dx_parameter_block * get_valid_parameter_block(D3DXHANDLE handle)
static D3DXHANDLE WINAPI d3dx_effect_GetFunction(ID3DXEffect *iface, UINT index)
HRESULT WINAPI D3DXCreateEffectFromResourceExW(struct IDirect3DDevice9 *device, HMODULE srcmodule, const WCHAR *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skipconstants, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
static BOOL walk_parameter_dep(struct d3dx_parameter *param, walk_parameter_dep_func param_func, void *data)
static unsigned int get_annotation_from_object(struct d3dx_effect *effect, D3DXHANDLE object, struct d3dx_parameter **annotations)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetDesc(ID3DXEffectCompiler *iface, D3DXEFFECT_DESC *desc)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunctionByName(ID3DXEffectCompiler *iface, const char *name)
static HRESULT WINAPI d3dx_effect_EndPass(ID3DXEffect *iface)
static D3DXHANDLE WINAPI d3dx_effect_EndParameterBlock(ID3DXEffect *iface)
static HRESULT WINAPI d3dx_effect_GetMatrixPointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
static HRESULT WINAPI d3dx_effect_GetInt(ID3DXEffect *iface, D3DXHANDLE parameter, INT *n)
static HRESULT WINAPI d3dx_effect_SetIntArray(ID3DXEffect *iface, D3DXHANDLE parameter, const INT *n, UINT count)
static HRESULT WINAPI d3dx_effect_GetVectorArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
HRESULT WINAPI D3DXCreateEffectCompiler(const char *srcdata, UINT srcdatalen, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **compiler, ID3DXBuffer **parse_errors)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBoolArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const BOOL *b, UINT count)
static D3DXHANDLE WINAPI d3dx_effect_GetPass(ID3DXEffect *iface, D3DXHANDLE technique, UINT index)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, float f)
static struct d3dx_technique * get_technique_by_name(struct d3dx_effect *effect, const char *name)
static HRESULT WINAPI d3dx_effect_GetIntArray(ID3DXEffect *iface, D3DXHANDLE parameter, INT *n, UINT count)
static void d3dx9_set_light_parameter(enum LIGHT_TYPE op, D3DLIGHT9 *light, void *value)
static HRESULT WINAPI d3dx_effect_SetMatrixTransposePointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count)
HRESULT WINAPI D3DXCreateEffectFromFileW(struct IDirect3DDevice9 *device, const WCHAR *srcfile, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
static HRESULT WINAPI d3dx_effect_GetDevice(ID3DXEffect *iface, struct IDirect3DDevice9 **device)
static HRESULT WINAPI d3dx_effect_SetString(ID3DXEffect *iface, D3DXHANDLE parameter, const char *string)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposeArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPassDesc(ID3DXEffectCompiler *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
static HRESULT d3dx9_apply_pass_states(struct d3dx_effect *effect, struct d3dx_pass *pass, BOOL update_all)
#define INT_FLOAT_MULTI_INVERSE
static ULONG WINAPI d3dx_effect_pool_AddRef(ID3DXEffectPool *iface)
static HRESULT WINAPI d3dx_effect_SetInt(ID3DXEffect *iface, D3DXHANDLE parameter, INT n)
static ULONG WINAPI d3dx_effect_AddRef(ID3DXEffect *iface)
static BOOL is_same_parameter(void *param1_, struct d3dx_parameter *param2)
HRESULT WINAPI D3DXCreateEffectPool(ID3DXEffectPool **pool)
static HRESULT WINAPI d3dx_effect_GetFloatArray(ID3DXEffect *iface, D3DXHANDLE parameter, float *f, UINT count)
static HRESULT d3dx9_apply_state(struct d3dx_effect *effect, struct d3dx_pass *pass, struct d3dx_state *state, unsigned int parent_index, BOOL update_all)
static void free_parameter_data(struct d3dx_parameter *param, BOOL child)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechnique(ID3DXEffectCompiler *iface, UINT index)
static int param_rb_compare(const void *key, const struct wine_rb_entry *entry)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTexture(struct ID3DXEffectCompiler *iface, D3DXHANDLE parameter, struct IDirect3DBaseTexture9 **texture)
static void free_technique(struct d3dx_technique *technique)
HRESULT WINAPI D3DXDisassembleEffect(ID3DXEffect *effect, BOOL enable_color_code, ID3DXBuffer **disassembly)
static void free_parameter(struct d3dx_parameter *param, BOOL element, BOOL child)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterElement(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloatArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const float *f, UINT count)
static HRESULT WINAPI d3dx_effect_GetFloat(ID3DXEffect *iface, D3DXHANDLE parameter, float *f)
static void * record_parameter(struct d3dx_effect *effect, struct d3dx_parameter *param, unsigned int bytes)
static HRESULT WINAPI d3dx_effect_GetStateManager(ID3DXEffect *iface, ID3DXEffectStateManager **manager)
static D3DXHANDLE WINAPI d3dx_effect_GetParameterByName(ID3DXEffect *iface, D3DXHANDLE parameter, const char *name)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTranspose(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
static struct d3dx_parameter * get_parameter_element_by_name(struct d3dx_effect *effect, struct d3dx_parameter *parameter, const char *name)
static ULONG WINAPI ID3DXEffectCompilerImpl_Release(ID3DXEffectCompiler *iface)
static HRESULT WINAPI d3dx_effect_GetMatrixTransposePointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
static BOOL walk_param_eval_dep(struct d3dx_param_eval *param_eval, walk_parameter_dep_func param_func, void *data)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVector(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXVECTOR4 *vector)
static HRESULT WINAPI ID3DXEffectCompilerImpl_QueryInterface(ID3DXEffectCompiler *iface, REFIID riid, void **object)
static void set_matrix(struct d3dx_parameter *param, const D3DXMATRIX *matrix, void *dst_data)
static void set_vector(struct d3dx_parameter *param, const D3DXVECTOR4 *vector, void *dst_data)
static BOOL is_parameter_used(struct d3dx_parameter *param, struct d3dx_technique *tech)
static HRESULT set_string(char **param_data, const char *string)
static HRESULT WINAPI d3dx_effect_SetMatrixTransposeArray(ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
static HRESULT WINAPI d3dx_effect_SetTechnique(ID3DXEffect *iface, D3DXHANDLE technique)
static DWORD d3dx9_effect_version(DWORD major, DWORD minor)
static HRESULT WINAPI d3dx_effect_GetDesc(ID3DXEffect *iface, D3DXEFFECT_DESC *desc)
static void free_parameter_block(struct d3dx_parameter_block *block)
static struct d3dx_effect_pool * impl_from_ID3DXEffectPool(ID3DXEffectPool *iface)
static HRESULT WINAPI d3dx_effect_GetPassDesc(ID3DXEffect *iface, D3DXHANDLE pass_handle, D3DXPASS_DESC *desc)
static struct d3dx_effect * impl_from_ID3DXEffect(ID3DXEffect *iface)
static HRESULT WINAPI d3dx_effect_GetBool(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b)
HRESULT WINAPI D3DXCreateEffectCompilerFromFileA(const char *srcfile, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors)
HRESULT WINAPI D3DXCreateEffectCompilerFromFileW(const WCHAR *srcfile, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors)
HRESULT WINAPI D3DXCreateEffectFromResourceW(struct IDirect3DDevice9 *device, HMODULE srcmodule, const WCHAR *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileShader(ID3DXEffectCompiler *iface, D3DXHANDLE function, const char *target, DWORD flags, ID3DXBuffer **shader, ID3DXBuffer **error_msgs, ID3DXConstantTable **constant_table)
static void d3dx9_set_material_parameter(enum MATERIAL_TYPE op, D3DMATERIAL9 *material, void *value)
static D3DXHANDLE WINAPI d3dx_effect_GetParameter(ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
static HRESULT WINAPI d3dx_effect_GetTechniqueDesc(ID3DXEffect *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
HRESULT WINAPI D3DXCreateEffectFromResourceExA(struct IDirect3DDevice9 *device, HMODULE srcmodule, const char *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skipconstants, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
static const char ** parse_skip_constants_string(char *skip_constants_string, unsigned int *names_count)
static struct d3dx_effect_pool * unsafe_impl_from_ID3DXEffectPool(ID3DXEffectPool *iface)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBoolArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
static HRESULT WINAPI d3dx_effect_CloneEffect(ID3DXEffect *iface, IDirect3DDevice9 *device, ID3DXEffect **new_effect)
static HRESULT set_value(struct d3dx_parameter *param, const void *data, unsigned int bytes, void *dst_data)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *literal)
static HRESULT WINAPI d3dx_effect_SetBool(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL b)
static HRESULT WINAPI d3dx_effect_GetBoolArray(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetTexture(struct ID3DXEffectCompiler *iface, D3DXHANDLE parameter, struct IDirect3DBaseTexture9 *texture)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechniqueByName(ID3DXEffectCompiler *iface, const char *name)
static char * next_valid_constant_name(char **string)
static D3DXHANDLE WINAPI d3dx_effect_GetAnnotationByName(ID3DXEffect *iface, D3DXHANDLE object, const char *name)
static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl
static D3DXHANDLE WINAPI d3dx_effect_GetTechniqueByName(ID3DXEffect *iface, const char *name)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixPointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
BOOL(* walk_parameter_dep_func)(void *data, struct d3dx_parameter *param)
static HRESULT WINAPI d3dx_effect_SetVector(ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXVECTOR4 *vector)
static HRESULT d3dx_set_shader_constants(struct d3dx_effect *effect, struct d3dx_pass *pass, struct d3dx_parameter *param, BOOL vs, BOOL update_all)
static HRESULT WINAPI d3dx_effect_GetValue(ID3DXEffect *iface, D3DXHANDLE parameter, void *data, UINT bytes)
static void add_param_to_tree(struct d3dx_effect *effect, struct d3dx_parameter *param, struct d3dx_parameter *parent, char separator, unsigned int element)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetValue(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const void *data, UINT bytes)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPass(ID3DXEffectCompiler *iface, D3DXHANDLE technique, UINT index)
static HRESULT d3dx_parse_value(struct d3dx_effect *effect, struct d3dx_parameter *param, void *value, const char *data, const char **ptr, struct d3dx_object *objects)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVertexShader(struct ID3DXEffectCompiler *iface, D3DXHANDLE parameter, struct IDirect3DVertexShader9 **shader)
static HRESULT WINAPI d3dx_effect_SetStateManager(ID3DXEffect *iface, ID3DXEffectStateManager *manager)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTranspose(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix)
static D3DXHANDLE WINAPI d3dx_effect_GetPassByName(ID3DXEffect *iface, D3DXHANDLE technique, const char *name)
static HRESULT WINAPI d3dx_effect_GetParameterDesc(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b)
static void free_parameter_object_data(struct d3dx_parameter *param, const void *data, unsigned int bytes)
static HRESULT d3dx_set_shader_const_state(struct d3dx_effect *effect, enum SHADER_CONSTANT_TYPE op, UINT index, struct d3dx_parameter *param, void *value_ptr)
HRESULT WINAPI D3DXCreateEffectEx(struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatalen, const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skip_constants, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors)
static HRESULT d3dx_parse_resource(struct d3dx_effect *effect, const char *data, const char **ptr, const char **skip_constants, unsigned int skip_constants_count)
static ULONG WINAPI d3dx_effect_pool_Release(ID3DXEffectPool *iface)
static HRESULT WINAPI d3dx_effect_FindNextValidTechnique(ID3DXEffect *iface, D3DXHANDLE technique, D3DXHANDLE *next_technique)
static HRESULT WINAPI d3dx_effect_BeginPass(ID3DXEffect *iface, UINT pass)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVector(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
static HRESULT d3dx_parse_effect_typedef(struct d3dx_effect *effect, struct d3dx_parameter *param, const char *data, const char **ptr, struct d3dx_parameter *parent, UINT flags)
static void free_state(struct d3dx_state *state)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposeArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotationByName(ID3DXEffectCompiler *iface, D3DXHANDLE object, const char *name)
static unsigned int get_recorded_parameter_size(const struct d3dx_recorded_parameter *record)
static D3DXHANDLE get_technique_handle(struct d3dx_technique *technique)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrix(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix)
static HRESULT WINAPI d3dx_effect_pool_QueryInterface(ID3DXEffectPool *iface, REFIID riid, void **object)
static void free_sampler(struct d3dx_sampler *sampler)
static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileEffect(ID3DXEffectCompiler *iface, DWORD flags, ID3DXBuffer **effect, ID3DXBuffer **error_msgs)
static void read_dword(const char **ptr, DWORD *d)
static HRESULT WINAPI d3dx_effect_SetArrayRange(ID3DXEffect *iface, D3DXHANDLE parameter, UINT start, UINT end)
static HRESULT WINAPI d3dx_effect_OnResetDevice(ID3DXEffect *iface)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT n)
static HRESULT WINAPI d3dx_effect_SetBoolArray(ID3DXEffect *iface, D3DXHANDLE parameter, const BOOL *b, UINT count)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
static HRESULT d3dx9_effect_init(struct d3dx_effect *effect, struct IDirect3DDevice9 *device, const char *data, SIZE_T data_size, const D3D_SHADER_MACRO *defines, ID3DInclude *include, UINT eflags, ID3DBlob **errors, struct ID3DXEffectPool *pool, const char *skip_constants_string)
static HRESULT WINAPI d3dx_effect_ApplyParameterBlock(ID3DXEffect *iface, D3DXHANDLE parameter_block)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameter(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
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)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFunctionDesc(ID3DXEffectCompiler *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
static D3DXHANDLE WINAPI d3dx_effect_GetCurrentTechnique(ID3DXEffect *iface)
static HRESULT d3dx_parse_sampler(struct d3dx_effect *effect, struct d3dx_sampler *sampler, const char *data, const char **ptr, struct d3dx_object *objects)
#define INITIAL_CONST_NAMES_SIZE
static HRESULT WINAPI d3dx_effect_End(ID3DXEffect *iface)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetIntArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const INT *n, UINT count)
static HRESULT d3dx9_create_object(struct d3dx_effect *effect, struct d3dx_object *object)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVectorArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
static BOOL WINAPI d3dx_effect_IsParameterUsed(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXHANDLE technique)
static void free_pass(struct d3dx_pass *pass)
static HRESULT WINAPI d3dx_effect_SetVectorArray(ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXVECTOR4 *vector, UINT count)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetIntArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n, UINT count)
static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl
HRESULT WINAPI D3DXCreateEffectCompilerFromResourceA(HMODULE srcmodule, const char *srcresource, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors)
static ULONG64 next_effect_update_version(struct d3dx_effect *effect)
static void skip_dword_unknown(const char **ptr, unsigned int count)
static HRESULT d3dx9_parse_name(char **name, const char *ptr)
static HRESULT WINAPI d3dx_effect_GetMatrixTranspose(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
static HRESULT d3dx_parse_effect_parameter(struct d3dx_effect *effect, struct d3dx_top_level_parameter *param, const char *data, const char **ptr, struct d3dx_object *objects)
HRESULT WINAPI D3DXCreateEffectFromFileExA(struct IDirect3DDevice9 *device, const char *srcfile, const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skipconstants, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
static HRESULT WINAPI d3dx_effect_SetMatrixPointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count)
static BOOL param_zero_data_func(void *dummy, struct d3dx_parameter *param)
HRESULT WINAPI D3DXCreateEffectFromFileExW(struct IDirect3DDevice9 *device, const WCHAR *srcfile, const D3DXMACRO *defines, struct ID3DXInclude *include, const char *skipconstants, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
static HRESULT WINAPI d3dx_effect_GetString(ID3DXEffect *iface, D3DXHANDLE parameter, const char **string)
static HRESULT WINAPI d3dx_effect_CommitChanges(ID3DXEffect *iface)
static void get_vector(struct d3dx_parameter *param, D3DXVECTOR4 *vector)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunction(ID3DXEffectCompiler *iface, UINT index)
static D3DXHANDLE WINAPI d3dx_effect_GetTechnique(ID3DXEffect *iface, UINT index)
static ULONG WINAPI d3dx_effect_Release(ID3DXEffect *iface)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetString(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const char **string)
static HRESULT WINAPI d3dx_effect_BeginParameterBlock(ID3DXEffect *iface)
static D3DXHANDLE WINAPI d3dx_effect_GetAnnotation(ID3DXEffect *iface, D3DXHANDLE object, UINT index)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPassByName(ID3DXEffectCompiler *iface, D3DXHANDLE technique, const char *name)
static BOOL param_set_top_level_param(void *top_level_param, struct d3dx_parameter *param)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetValue(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, void *data, UINT bytes)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, float *f)
static HRESULT WINAPI d3dx_effect_GetVector(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX *matrix, UINT count)
static void param_set_data_pointer(struct d3dx_parameter *param, unsigned char *data, BOOL child, BOOL free_data)
static void set_dirty(struct d3dx_parameter *param)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetArrayRange(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT start, UINT end)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXMATRIX **matrix, UINT count)
static D3DXHANDLE get_pass_handle(struct d3dx_pass *pass)
HRESULT WINAPI D3DXCreateEffectFromResourceA(struct IDirect3DDevice9 *device, HMODULE srcmodule, const char *srcresource, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilationerrors)
static D3DXHANDLE get_parameter_handle(struct d3dx_parameter *parameter)
static ULONG WINAPI ID3DXEffectCompilerImpl_AddRef(ID3DXEffectCompiler *iface)
static void get_matrix(struct d3dx_parameter *param, D3DXMATRIX *matrix, BOOL transpose)
static HRESULT WINAPI d3dx_effect_GetPool(ID3DXEffect *iface, ID3DXEffectPool **pool)
static HRESULT WINAPI d3dx_effect_Begin(ID3DXEffect *iface, UINT *passes, DWORD flags)
static HRESULT d3dx_pool_sync_shared_parameter(struct d3dx_effect_pool *pool, struct d3dx_top_level_parameter *param)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterBySemantic(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const char *semantic)
static HRESULT WINAPI d3dx_effect_SetFloatArray(ID3DXEffect *iface, D3DXHANDLE parameter, const float *f, UINT count)
static HRESULT d3dx_parse_init_value(struct d3dx_effect *effect, struct d3dx_parameter *param, const char *data, const char *ptr, struct d3dx_object *objects)
static HRESULT WINAPI d3dx_effect_GetPixelShader(ID3DXEffect *iface, D3DXHANDLE parameter, IDirect3DPixelShader9 **shader)
HRESULT WINAPI D3DXCreateEffectCompilerFromResourceW(HMODULE srcmodule, const WCHAR *srcresource, const D3DXMACRO *defines, ID3DXInclude *include, DWORD flags, ID3DXEffectCompiler **effectcompiler, ID3DXBuffer **parseerrors)
static HRESULT WINAPI d3dx_effect_SetTexture(ID3DXEffect *iface, D3DXHANDLE parameter, IDirect3DBaseTexture9 *texture)
static HRESULT d3dx_parse_array_selector(struct d3dx_effect *effect, struct d3dx_state *state, const char **skip_constants, unsigned int skip_constants_count)
static HRESULT WINAPI d3dx_effect_GetFunctionDesc(ID3DXEffect *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
static D3DXHANDLE WINAPI d3dx_effect_GetFunctionByName(ID3DXEffect *iface, const char *name)
static HRESULT WINAPI d3dx_effect_SetValue(ID3DXEffect *iface, D3DXHANDLE parameter, const void *data, UINT bytes)
static struct d3dx_parameter * get_annotation_by_name(struct d3dx_effect *effect, unsigned int count, struct d3dx_parameter *annotations, const char *name)
static struct d3dx_pass * get_valid_pass(struct d3dx_effect *effect, D3DXHANDLE pass)
static struct d3dx_technique * get_valid_technique(struct d3dx_effect *effect, D3DXHANDLE technique)
static HRESULT d3dx_parse_effect(struct d3dx_effect *effect, const char *data, UINT data_size, DWORD start, const char **skip_constants, unsigned int skip_constants_count)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTechniqueDesc(ID3DXEffectCompiler *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
static void * param_get_data_and_dirtify(struct d3dx_effect *effect, struct d3dx_parameter *param, unsigned int bytes, BOOL value_changed)
#define PARAMETER_FLAG_SHARED
static struct ID3DXEffectCompilerImpl * impl_from_ID3DXEffectCompiler(ID3DXEffectCompiler *iface)
#define INITIAL_POOL_SIZE
static struct d3dx_parameter * get_valid_parameter(struct d3dx_effect *effect, D3DXHANDLE parameter)
struct d3dx_parameter * get_parameter_by_name(struct d3dx_effect *effect, struct d3dx_parameter *parameter, const char *name)
static void free_effect_pool(struct d3dx_effect_pool *pool)
static HRESULT WINAPI d3dx_effect_GetMatrixArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrix(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
static BOOL walk_state_dep(struct d3dx_state *state, walk_parameter_dep_func param_func, void *data)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloatArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, float *f, UINT count)
static void d3dx_effect_cleanup(struct d3dx_effect *effect)
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)
static void set_matrix_transpose(struct d3dx_parameter *param, const D3DXMATRIX *matrix, void *dst_data)
#define INITIAL_PARAM_BLOCK_SIZE
static const char parameter_block_magic_string[4]
static HRESULT WINAPI d3dx_effect_SetFloat(ID3DXEffect *iface, D3DXHANDLE parameter, float f)
HRESULT WINAPI D3DXCreateEffect(struct IDirect3DDevice9 *device, const void *srcdata, UINT srcdatalen, const D3DXMACRO *defines, struct ID3DXInclude *include, DWORD flags, struct ID3DXEffectPool *pool, struct ID3DXEffect **effect, struct ID3DXBuffer **compilation_errors)
static D3DXHANDLE WINAPI d3dx_effect_GetParameterBySemantic(ID3DXEffect *iface, D3DXHANDLE parameter, const char *semantic)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotation(ID3DXEffectCompiler *iface, D3DXHANDLE object, UINT index)
static const char parameter_magic_string[4]
static D3DXHANDLE WINAPI d3dx_effect_GetParameterElement(ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVectorArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const D3DXVECTOR4 *vector, UINT count)
static void free_object(struct d3dx_object *object)
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterByName(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, const char *name)
static HRESULT WINAPI d3dx_effect_GetTexture(ID3DXEffect *iface, D3DXHANDLE parameter, IDirect3DBaseTexture9 **texture)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL literal)
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL b)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPixelShader(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, struct IDirect3DPixelShader9 **shader)
static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl
static HRESULT WINAPI d3dx_effect_GetMatrix(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetParameterDesc(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
static HRESULT WINAPI d3dx_effect_ValidateTechnique(ID3DXEffect *iface, D3DXHANDLE technique)
static void d3dx_pool_release_shared_parameter(struct d3dx_top_level_parameter *param)
static HRESULT d3dx9_copy_data(struct d3dx_effect *effect, unsigned int object_id, const char **ptr)
CRITICAL_SECTION from_file_mutex
const struct ID3DXIncludeVtbl d3dx_include_from_file_vtbl
static __inline const char * debugstr_an(const char *s, int n)
#define stricmp(_String1, _String2)
#define HeapFree(x, y, z)
#define WideCharToMultiByte
#define MultiByteToWideChar
static const WCHAR separator[]
HRSRC WINAPI FindResourceW(HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
HRSRC WINAPI FindResourceA(HMODULE hModule, LPCSTR name, LPCSTR type)
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
#define rb_entry(ptr, type, member)
GLuint GLuint GLsizei GLenum type
GLuint GLuint GLsizei count
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
GLboolean GLboolean GLboolean b
GLsizei GLboolean transpose
GLenum const GLfloat * params
GLuint GLsizei GLsizei * length
GLsizeiptr const GLvoid GLenum usage
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum light
_Check_return_ int __cdecl atoi(_In_z_ const char *_Str)
#define memcpy(s1, s2, n)
#define memmove(s1, s2, n)
static const CLSID * objects[]
#define sprintf(buf, format,...)
static const WCHAR desc[]
static float(__cdecl *square_half_float)(float x
png_const_structrp png_const_inforp int * unit
#define IsEqualGUID(rguid1, rguid2)
static unsigned __int64 next
_Check_return_ _CRTIMP size_t __cdecl strcspn(_In_z_ const char *_Str, _In_z_ const char *_Control)
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
#define WINE_RB_ENTRY_VALUE(element, type, field)
static struct wine_rb_entry * wine_rb_get(const struct wine_rb_tree *tree, const void *key)
static void wine_rb_init(struct wine_rb_tree *tree, wine_rb_compare_func_t compare)
static int wine_rb_put(struct wine_rb_tree *tree, const void *key, struct wine_rb_entry *entry)
ID3DXEffectCompiler ID3DXEffectCompiler_iface
ID3DXEffectPool ID3DXEffectPool_iface
struct d3dx_shared_data * shared_data
D3DMATERIAL9 current_material
struct d3dx_technique * active_technique
struct d3dx_top_level_parameter * parameters
unsigned int technique_count
unsigned int object_count
struct d3dx_technique * techniques
struct d3dx_pass * active_pass
D3DLIGHT9 current_light[8]
struct ID3DXEffectStateManager * manager
unsigned int full_name_tmp_size
unsigned int light_updated
struct d3dx_object * objects
struct IDirect3DDevice9 * device
struct d3dx_effect_pool * pool
ID3DXEffect ID3DXEffect_iface
struct wine_rb_tree param_tree
unsigned int parameter_count
struct list parameter_block_list
struct d3dx_parameter_block * current_parameter_block
ID3DXInclude ID3DXInclude_iface
struct d3dx_parameter * param
struct d3dx_effect * effect
char magic_string[ARRAY_SIZE(parameter_block_magic_string)]
struct d3dx_parameter * members
struct d3dx_param_eval * param_eval
D3DXPARAMETER_CLASS class
struct d3dx_parameter * annotations
struct d3dx_state * states
struct d3dx_parameter * param
struct d3dx_state * states
struct d3dx_top_level_parameter ** parameters
struct d3dx_parameter * referenced_param
struct d3dx_parameter parameter
struct d3dx_pass * passes
struct d3dx_parameter * annotations
struct IDirect3DStateBlock9 * saved_state
struct d3dx_shared_data * shared_data
struct d3dx_parameter * annotations
ULONG64 * version_counter
#define FIELD_OFFSET(t, f)
#define CONTAINING_RECORD(address, type, field)
WDF_EXTERN_C_START typedef _In_ WDFDEVICE _In_ WDFCONTEXT _In_ WDF_DMA_DIRECTION Direction
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static unsigned int block