ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

wined3d: Remove no longer used device state functions. 

Signed-off-by: Zebediah Figura <z.figura12@gmail.com>
Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Zebediah Figura 2020-03-03 17:50:03 -06:00 committed by Alexandre Julliard
parent 70b3a2624a
commit 027e2b01fa
3 changed files with 0 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

250
dlls/wined3d/device.c
View File

@ -1350,21 +1350,6 @@ HRESULT CDECL wined3d_device_set_stream_source_freq(struct wined3d_device *devic
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_get_stream_source_freq(const struct wined3d_device *device,
UINT stream_idx, UINT *divider)
{
const struct wined3d_stream_state *stream;
TRACE("device %p, stream_idx %u, divider %p.\n", device, stream_idx, divider);
stream = &device->state.streams[stream_idx];
*divider = stream->flags | stream->frequency;
TRACE("Returning %#x.\n", *divider);
return WINED3D_OK;
}
void CDECL wined3d_device_set_transform(struct wined3d_device *device,
enum wined3d_transform_state d3dts, const struct wined3d_matrix *matrix)
{
@ -1399,26 +1384,6 @@ void CDECL wined3d_device_get_transform(const struct wined3d_device *device,
*matrix = device->state.transforms[state];
}
void CDECL wined3d_device_multiply_transform(struct wined3d_device *device,
enum wined3d_transform_state state, const struct wined3d_matrix *matrix)
{
struct wined3d_matrix *mat;
TRACE("device %p, state %s, matrix %p.\n", device, debug_d3dtstype(state), matrix);
if (state > WINED3D_HIGHEST_TRANSFORM_STATE)
{
WARN("Unhandled transform state %#x.\n", state);
return;
}
/* Tests show that stateblock recording is ignored; the change goes directly
* into the primary stateblock. */
mat = &device->state.transforms[state];
multiply_matrix(mat, mat, matrix);
wined3d_cs_emit_set_transform(device->cs, state, mat);
}
/* Note lights are real special cases. Although the device caps state only
* e.g. 8 are supported, you can reference any indexes you want as long as
* that number max are enabled at any one point in time. Therefore since the
@ -1558,23 +1523,6 @@ HRESULT CDECL wined3d_device_set_light(struct wined3d_device *device,
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_get_light(const struct wined3d_device *device,
UINT light_idx, struct wined3d_light *light)
{
struct wined3d_light_info *light_info;
TRACE("device %p, light_idx %u, light %p.\n", device, light_idx, light);
if (!(light_info = wined3d_light_state_get_light(&device->state.light_state, light_idx)))
{
TRACE("Light information requested but light not defined\n");
return WINED3DERR_INVALIDCALL;
}
*light = light_info->OriginalParms;
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_set_light_enable(struct wined3d_device *device, UINT light_idx, BOOL enable)
{
struct wined3d_light_info *light_info;
@ -1600,22 +1548,6 @@ HRESULT CDECL wined3d_device_set_light_enable(struct wined3d_device *device, UIN
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_get_light_enable(const struct wined3d_device *device, UINT light_idx, BOOL *enable)
{
struct wined3d_light_info *light_info;
TRACE("device %p, light_idx %u, enable %p.\n", device, light_idx, enable);
if (!(light_info = wined3d_light_state_get_light(&device->state.light_state, light_idx)))
{
TRACE("Light enabled state requested but light not defined.\n");
return WINED3DERR_INVALIDCALL;
}
/* true is 128 according to SetLightEnable */
*enable = light_info->enabled ? 128 : 0;
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_set_clip_plane(struct wined3d_device *device,
UINT plane_idx, const struct wined3d_vec4 *plane)
{
@ -1640,22 +1572,6 @@ HRESULT CDECL wined3d_device_set_clip_plane(struct wined3d_device *device,
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_get_clip_plane(const struct wined3d_device *device,
UINT plane_idx, struct wined3d_vec4 *plane)
{
TRACE("device %p, plane_idx %u, plane %p.\n", device, plane_idx, plane);
if (plane_idx >= device->adapter->d3d_info.limits.max_clip_distances)
{
TRACE("Application has requested clipplane this device doesn't support.\n");
return WINED3DERR_INVALIDCALL;
}
*plane = device->state.clip_planes[plane_idx];
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_set_clip_status(struct wined3d_device *device,
const struct wined3d_clip_status *clip_status)
{
@ -1686,19 +1602,6 @@ void CDECL wined3d_device_set_material(struct wined3d_device *device, const stru
wined3d_cs_emit_set_material(device->cs, material);
}
void CDECL wined3d_device_get_material(const struct wined3d_device *device, struct wined3d_material *material)
{
TRACE("device %p, material %p.\n", device, material);
*material = device->state.material;
TRACE("diffuse %s\n", debug_color(&material->diffuse));
TRACE("ambient %s\n", debug_color(&material->ambient));
TRACE("specular %s\n", debug_color(&material->specular));
TRACE("emissive %s\n", debug_color(&material->emissive));
TRACE("power %.8e.\n", material->power);
}
void CDECL wined3d_device_set_index_buffer(struct wined3d_device *device,
struct wined3d_buffer *buffer, enum wined3d_format_id format_id, unsigned int offset)
{
@ -1744,13 +1647,6 @@ void CDECL wined3d_device_set_base_vertex_index(struct wined3d_device *device, I
device->state.base_vertex_index = base_index;
}
INT CDECL wined3d_device_get_base_vertex_index(const struct wined3d_device *device)
{
TRACE("device %p.\n", device);
return device->state.base_vertex_index;
}
void CDECL wined3d_device_set_viewports(struct wined3d_device *device, unsigned int viewport_count,
const struct wined3d_viewport *viewports)
{
@ -1922,24 +1818,6 @@ void CDECL wined3d_device_set_sampler_state(struct wined3d_device *device,
wined3d_cs_emit_set_sampler_state(device->cs, sampler_idx, state, value);
}
DWORD CDECL wined3d_device_get_sampler_state(const struct wined3d_device *device,
UINT sampler_idx, enum wined3d_sampler_state state)
{
TRACE("device %p, sampler_idx %u, state %s.\n",
device, sampler_idx, debug_d3dsamplerstate(state));
if (sampler_idx >= WINED3DVERTEXTEXTURESAMPLER0 && sampler_idx <= WINED3DVERTEXTEXTURESAMPLER3)
sampler_idx -= (WINED3DVERTEXTEXTURESAMPLER0 - WINED3D_MAX_FRAGMENT_SAMPLERS);
if (sampler_idx >= ARRAY_SIZE(device->state.sampler_states))
{
WARN("Invalid sampler %u.\n", sampler_idx);
return 0; /* Windows accepts overflowing this array ... we do not. */
}
return device->state.sampler_states[sampler_idx][state];
}
void CDECL wined3d_device_set_scissor_rects(struct wined3d_device *device, unsigned int rect_count,
const RECT *rects)
{
@ -2208,22 +2086,6 @@ HRESULT CDECL wined3d_device_set_vs_consts_b(struct wined3d_device *device,
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_get_vs_consts_b(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, BOOL *constants)
{
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
if (!constants || start_idx >= WINED3D_MAX_CONSTS_B)
return WINED3DERR_INVALIDCALL;
if (count > WINED3D_MAX_CONSTS_B - start_idx)
count = WINED3D_MAX_CONSTS_B - start_idx;
memcpy(constants, &device->state.vs_consts_b[start_idx], count * sizeof(*constants));
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_set_vs_consts_i(struct wined3d_device *device,
unsigned int start_idx, unsigned int count, const struct wined3d_ivec4 *constants)
{
@ -2250,21 +2112,6 @@ HRESULT CDECL wined3d_device_set_vs_consts_i(struct wined3d_device *device,
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_get_vs_consts_i(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, struct wined3d_ivec4 *constants)
{
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
if (!constants || start_idx >= WINED3D_MAX_CONSTS_I)
return WINED3DERR_INVALIDCALL;
if (count > WINED3D_MAX_CONSTS_I - start_idx)
count = WINED3D_MAX_CONSTS_I - start_idx;
memcpy(constants, &device->state.vs_consts_i[start_idx], count * sizeof(*constants));
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_set_vs_consts_f(struct wined3d_device *device,
unsigned int start_idx, unsigned int count, const struct wined3d_vec4 *constants)
{
@ -2290,23 +2137,6 @@ HRESULT CDECL wined3d_device_set_vs_consts_f(struct wined3d_device *device,
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_get_vs_consts_f(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, struct wined3d_vec4 *constants)
{
const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
if (!constants || start_idx >= d3d_info->limits.vs_uniform_count
|| count > d3d_info->limits.vs_uniform_count - start_idx)
return WINED3DERR_INVALIDCALL;
memcpy(constants, &device->state.vs_consts_f[start_idx], count * sizeof(*constants));
return WINED3D_OK;
}
void CDECL wined3d_device_set_pixel_shader(struct wined3d_device *device, struct wined3d_shader *shader)
{
struct wined3d_shader *prev = device->state.shader[WINED3D_SHADER_TYPE_PIXEL];
@ -2387,22 +2217,6 @@ HRESULT CDECL wined3d_device_set_ps_consts_b(struct wined3d_device *device,
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_get_ps_consts_b(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, BOOL *constants)
{
TRACE("device %p, start_idx %u, count %u,constants %p.\n",
device, start_idx, count, constants);
if (!constants || start_idx >= WINED3D_MAX_CONSTS_B)
return WINED3DERR_INVALIDCALL;
if (count > WINED3D_MAX_CONSTS_B - start_idx)
count = WINED3D_MAX_CONSTS_B - start_idx;
memcpy(constants, &device->state.ps_consts_b[start_idx], count * sizeof(*constants));
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_set_ps_consts_i(struct wined3d_device *device,
unsigned int start_idx, unsigned int count, const struct wined3d_ivec4 *constants)
{
@ -2429,22 +2243,6 @@ HRESULT CDECL wined3d_device_set_ps_consts_i(struct wined3d_device *device,
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_get_ps_consts_i(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, struct wined3d_ivec4 *constants)
{
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
if (!constants || start_idx >= WINED3D_MAX_CONSTS_I)
return WINED3DERR_INVALIDCALL;
if (count > WINED3D_MAX_CONSTS_I - start_idx)
count = WINED3D_MAX_CONSTS_I - start_idx;
memcpy(constants, &device->state.ps_consts_i[start_idx], count * sizeof(*constants));
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_set_ps_consts_f(struct wined3d_device *device,
unsigned int start_idx, unsigned int count, const struct wined3d_vec4 *constants)
{
@ -2470,23 +2268,6 @@ HRESULT CDECL wined3d_device_set_ps_consts_f(struct wined3d_device *device,
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_get_ps_consts_f(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, struct wined3d_vec4 *constants)
{
const struct wined3d_d3d_info *d3d_info = &device->adapter->d3d_info;
TRACE("device %p, start_idx %u, count %u, constants %p.\n",
device, start_idx, count, constants);
if (!constants || start_idx >= d3d_info->limits.ps_uniform_count
|| count > d3d_info->limits.ps_uniform_count - start_idx)
return WINED3DERR_INVALIDCALL;
memcpy(constants, &device->state.ps_consts_f[start_idx], count * sizeof(*constants));
return WINED3D_OK;
}
void CDECL wined3d_device_set_hull_shader(struct wined3d_device *device, struct wined3d_shader *shader)
{
struct wined3d_shader *prev;
@ -3763,21 +3544,6 @@ void CDECL wined3d_device_set_texture_stage_state(struct wined3d_device *device,
wined3d_cs_emit_set_texture_state(device->cs, stage, state, value);
}
DWORD CDECL wined3d_device_get_texture_stage_state(const struct wined3d_device *device,
UINT stage, enum wined3d_texture_stage_state state)
{
TRACE("device %p, stage %u, state %s.\n",
device, stage, debug_d3dtexturestate(state));
if (state > WINED3D_HIGHEST_TEXTURE_STATE)
{
WARN("Invalid state %#x passed.\n", state);
return 0;
}
return device->state.texture_states[stage][state];
}
void CDECL wined3d_device_set_texture(struct wined3d_device *device,
UINT stage, struct wined3d_texture *texture)
{
@ -3816,22 +3582,6 @@ void CDECL wined3d_device_set_texture(struct wined3d_device *device,
return;
}
struct wined3d_texture * CDECL wined3d_device_get_texture(const struct wined3d_device *device, UINT stage)
{
TRACE("device %p, stage %u.\n", device, stage);
if (stage >= WINED3DVERTEXTEXTURESAMPLER0 && stage <= WINED3DVERTEXTEXTURESAMPLER3)
stage -= (WINED3DVERTEXTEXTURESAMPLER0 - WINED3D_MAX_FRAGMENT_SAMPLERS);
if (stage >= ARRAY_SIZE(device->state.textures))
{
WARN("Ignoring invalid stage %u.\n", stage);
return NULL; /* Windows accepts overflowing this array ... we do not. */
}
return device->state.textures[stage];
}
void CDECL wined3d_device_apply_stateblock(struct wined3d_device *device,
struct wined3d_stateblock *stateblock)
{

16
dlls/wined3d/wined3d.spec
View File

@ -61,9 +61,7 @@
@ cdecl wined3d_device_end_scene(ptr)
@ cdecl wined3d_device_evict_managed_resources(ptr)
@ cdecl wined3d_device_get_available_texture_mem(ptr)
@ cdecl wined3d_device_get_base_vertex_index(ptr)
@ cdecl wined3d_device_get_blend_state(ptr ptr)
@ cdecl wined3d_device_get_clip_plane(ptr long ptr)
@ cdecl wined3d_device_get_clip_status(ptr ptr)
@ cdecl wined3d_device_get_compute_shader(ptr)
@ cdecl wined3d_device_get_constant_buffer(ptr long long)
@ -86,46 +84,32 @@
@ cdecl wined3d_device_get_hs_sampler(ptr long)
@ cdecl wined3d_device_get_hull_shader(ptr)
@ cdecl wined3d_device_get_index_buffer(ptr ptr ptr)
@ cdecl wined3d_device_get_light(ptr long ptr)
@ cdecl wined3d_device_get_light_enable(ptr long ptr)
@ cdecl wined3d_device_get_material(ptr ptr)
@ cdecl wined3d_device_get_max_frame_latency(ptr)
@ cdecl wined3d_device_get_npatch_mode(ptr)
@ cdecl wined3d_device_get_pixel_shader(ptr)
@ cdecl wined3d_device_get_predication(ptr ptr)
@ cdecl wined3d_device_get_primitive_type(ptr ptr ptr)
@ cdecl wined3d_device_get_ps_consts_b(ptr long long ptr)
@ cdecl wined3d_device_get_ps_consts_f(ptr long long ptr)
@ cdecl wined3d_device_get_ps_consts_i(ptr long long ptr)
@ cdecl wined3d_device_get_ps_resource_view(ptr long)
@ cdecl wined3d_device_get_ps_sampler(ptr long)
@ cdecl wined3d_device_get_raster_status(ptr long ptr)
@ cdecl wined3d_device_get_rasterizer_state(ptr)
@ cdecl wined3d_device_get_render_state(ptr long)
@ cdecl wined3d_device_get_rendertarget_view(ptr long)
@ cdecl wined3d_device_get_sampler_state(ptr long long)
@ cdecl wined3d_device_get_scissor_rects(ptr ptr ptr)
@ cdecl wined3d_device_get_software_vertex_processing(ptr)
@ cdecl wined3d_device_get_stream_output(ptr long ptr)
@ cdecl wined3d_device_get_stream_source(ptr long ptr ptr ptr)
@ cdecl wined3d_device_get_stream_source_freq(ptr long ptr)
@ cdecl wined3d_device_get_swapchain(ptr long)
@ cdecl wined3d_device_get_swapchain_count(ptr)
@ cdecl wined3d_device_get_texture(ptr long)
@ cdecl wined3d_device_get_texture_stage_state(ptr long long)
@ cdecl wined3d_device_get_transform(ptr long ptr)
@ cdecl wined3d_device_get_unordered_access_view(ptr long)
@ cdecl wined3d_device_get_vertex_declaration(ptr)
@ cdecl wined3d_device_get_vertex_shader(ptr)
@ cdecl wined3d_device_get_viewports(ptr ptr ptr)
@ cdecl wined3d_device_get_vs_consts_b(ptr long long ptr)
@ cdecl wined3d_device_get_vs_consts_f(ptr long long ptr)
@ cdecl wined3d_device_get_vs_consts_i(ptr long long ptr)
@ cdecl wined3d_device_get_vs_resource_view(ptr long)
@ cdecl wined3d_device_get_vs_sampler(ptr long)
@ cdecl wined3d_device_get_wined3d(ptr)
@ cdecl wined3d_device_incref(ptr)
@ cdecl wined3d_device_multiply_transform(ptr long ptr)
@ cdecl wined3d_device_process_vertices(ptr long long long ptr ptr long long)
@ cdecl wined3d_device_release_focus_window(ptr)
@ cdecl wined3d_device_reset(ptr ptr ptr ptr long)

28
include/wine/wined3d.h
View File

@ -2338,11 +2338,8 @@ void __cdecl wined3d_device_draw_primitive_instanced_indirect(struct wined3d_dev
HRESULT __cdecl wined3d_device_end_scene(struct wined3d_device *device);
void __cdecl wined3d_device_evict_managed_resources(struct wined3d_device *device);
UINT __cdecl wined3d_device_get_available_texture_mem(const struct wined3d_device *device);
INT __cdecl wined3d_device_get_base_vertex_index(const struct wined3d_device *device);
struct wined3d_blend_state * __cdecl wined3d_device_get_blend_state(const struct wined3d_device *device,
struct wined3d_color *blend_factor);
HRESULT __cdecl wined3d_device_get_clip_plane(const struct wined3d_device *device,
UINT plane_idx, struct wined3d_vec4 *plane);
HRESULT __cdecl wined3d_device_get_clip_status(const struct wined3d_device *device,
struct wined3d_clip_status *clip_status);
struct wined3d_shader * __cdecl wined3d_device_get_compute_shader(const struct wined3d_device *device);
@ -2376,22 +2373,12 @@ struct wined3d_sampler * __cdecl wined3d_device_get_hs_sampler(const struct wine
struct wined3d_shader * __cdecl wined3d_device_get_hull_shader(const struct wined3d_device *device);
struct wined3d_buffer * __cdecl wined3d_device_get_index_buffer(const struct wined3d_device *device,
enum wined3d_format_id *format, unsigned int *offset);
HRESULT __cdecl wined3d_device_get_light(const struct wined3d_device *device,
UINT light_idx, struct wined3d_light *light);
HRESULT __cdecl wined3d_device_get_light_enable(const struct wined3d_device *device, UINT light_idx, BOOL *enable);
void __cdecl wined3d_device_get_material(const struct wined3d_device *device, struct wined3d_material *material);
unsigned int __cdecl wined3d_device_get_max_frame_latency(const struct wined3d_device *device);
float __cdecl wined3d_device_get_npatch_mode(const struct wined3d_device *device);
struct wined3d_shader * __cdecl wined3d_device_get_pixel_shader(const struct wined3d_device *device);
struct wined3d_query * __cdecl wined3d_device_get_predication(struct wined3d_device *device, BOOL *value);
void __cdecl wined3d_device_get_primitive_type(const struct wined3d_device *device,
enum wined3d_primitive_type *primitive_topology, unsigned int *patch_vertex_count);
HRESULT __cdecl wined3d_device_get_ps_consts_b(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, BOOL *constants);
HRESULT __cdecl wined3d_device_get_ps_consts_f(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, struct wined3d_vec4 *constants);
HRESULT __cdecl wined3d_device_get_ps_consts_i(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, struct wined3d_ivec4 *constants);
struct wined3d_shader_resource_view * __cdecl wined3d_device_get_ps_resource_view(const struct wined3d_device *device,
UINT idx);
struct wined3d_sampler * __cdecl wined3d_device_get_ps_sampler(const struct wined3d_device *device, UINT idx);
@ -2401,8 +2388,6 @@ struct wined3d_rasterizer_state * __cdecl wined3d_device_get_rasterizer_state(st
DWORD __cdecl wined3d_device_get_render_state(const struct wined3d_device *device, enum wined3d_render_state state);
struct wined3d_rendertarget_view * __cdecl wined3d_device_get_rendertarget_view(const struct wined3d_device *device,
unsigned int view_idx);
DWORD __cdecl wined3d_device_get_sampler_state(const struct wined3d_device *device,
UINT sampler_idx, enum wined3d_sampler_state state);
void __cdecl wined3d_device_get_scissor_rects(const struct wined3d_device *device, unsigned int *rect_count,
RECT *rect);
BOOL __cdecl wined3d_device_get_software_vertex_processing(const struct wined3d_device *device);
@ -2410,14 +2395,9 @@ struct wined3d_buffer * __cdecl wined3d_device_get_stream_output(struct wined3d_
UINT idx, UINT *offset);
HRESULT __cdecl wined3d_device_get_stream_source(const struct wined3d_device *device,
UINT stream_idx, struct wined3d_buffer **buffer, UINT *offset, UINT *stride);
HRESULT __cdecl wined3d_device_get_stream_source_freq(const struct wined3d_device *device,
UINT stream_idx, UINT *divider);
struct wined3d_swapchain * __cdecl wined3d_device_get_swapchain(const struct wined3d_device *device,
UINT swapchain_idx);
UINT __cdecl wined3d_device_get_swapchain_count(const struct wined3d_device *device);
struct wined3d_texture * __cdecl wined3d_device_get_texture(const struct wined3d_device *device, UINT stage);
DWORD __cdecl wined3d_device_get_texture_stage_state(const struct wined3d_device *device,
UINT stage, enum wined3d_texture_stage_state state);
void __cdecl wined3d_device_get_transform(const struct wined3d_device *device,
enum wined3d_transform_state state, struct wined3d_matrix *matrix);
struct wined3d_unordered_access_view * __cdecl wined3d_device_get_unordered_access_view(
@ -2426,19 +2406,11 @@ struct wined3d_vertex_declaration * __cdecl wined3d_device_get_vertex_declaratio
struct wined3d_shader * __cdecl wined3d_device_get_vertex_shader(const struct wined3d_device *device);
void __cdecl wined3d_device_get_viewports(const struct wined3d_device *device, unsigned int *viewport_count,
struct wined3d_viewport *viewports);
HRESULT __cdecl wined3d_device_get_vs_consts_b(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, BOOL *constants);
HRESULT __cdecl wined3d_device_get_vs_consts_f(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, struct wined3d_vec4 *constants);
HRESULT __cdecl wined3d_device_get_vs_consts_i(const struct wined3d_device *device,
unsigned int start_idx, unsigned int count, struct wined3d_ivec4 *constants);
struct wined3d_shader_resource_view * __cdecl wined3d_device_get_vs_resource_view(const struct wined3d_device *device,
UINT idx);
struct wined3d_sampler * __cdecl wined3d_device_get_vs_sampler(const struct wined3d_device *device, UINT idx);
struct wined3d * __cdecl wined3d_device_get_wined3d(const struct wined3d_device *device);
ULONG __cdecl wined3d_device_incref(struct wined3d_device *device);
void __cdecl wined3d_device_multiply_transform(struct wined3d_device *device,
enum wined3d_transform_state state, const struct wined3d_matrix *matrix);
HRESULT __cdecl wined3d_device_process_vertices(struct wined3d_device *device,
UINT src_start_idx, UINT dst_idx, UINT vertex_count, struct wined3d_buffer *dst_buffer,
const struct wined3d_vertex_declaration *declaration, DWORD flags, DWORD dst_fvf);