[PATCH 2/2] wined3d: Use unsigned mask constants in shifts.
Henri Verbeet
hverbeet at codeweavers.com
Wed Aug 26 05:46:47 CDT 2015
---
dlls/wined3d/arb_program_shader.c | 66 ++++++++++++++-----------
dlls/wined3d/buffer.c | 8 +--
dlls/wined3d/context.c | 40 +++++++--------
dlls/wined3d/device.c | 36 +++++++-------
dlls/wined3d/directx.c | 2 +-
dlls/wined3d/drawprim.c | 24 ++++-----
dlls/wined3d/glsl_shader.c | 96 ++++++++++++++++++------------------
dlls/wined3d/nvidia_texture_shader.c | 12 +++--
dlls/wined3d/shader.c | 70 +++++++++++++-------------
dlls/wined3d/shader_sm1.c | 38 +++++++-------
dlls/wined3d/shader_sm4.c | 28 +++++------
dlls/wined3d/state.c | 62 +++++++++++------------
dlls/wined3d/stateblock.c | 22 ++++-----
dlls/wined3d/surface.c | 16 +++---
dlls/wined3d/utils.c | 62 +++++++++++------------
dlls/wined3d/wined3d_private.h | 64 ++++++++++++------------
include/wine/wined3d.h | 38 +++++++-------
17 files changed, 348 insertions(+), 336 deletions(-)
diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c
index 4232f35..6a321db 100644
--- a/dlls/wined3d/arb_program_shader.c
+++ b/dlls/wined3d/arb_program_shader.c
@@ -805,7 +805,8 @@ static void shader_generate_arb_declarations(const struct wined3d_shader *shader
{
DWORD idx = i >> 5;
DWORD shift = i & 0x1f;
- if(reg_maps->constf[idx] & (1 << shift)) highest_constf = i;
+ if (reg_maps->constf[idx] & (1u << shift))
+ highest_constf = i;
}
if(use_nv_clip(gl_info) && ctx->target_version >= NV2)
@@ -890,11 +891,14 @@ static void shader_generate_arb_declarations(const struct wined3d_shader *shader
/* Need to PARAM the environment parameters (constants) so we can use relative addressing */
shader_addline(buffer, "PARAM C[%d] = { program.env[0..%d] };\n",
max_constantsF, max_constantsF - 1);
- } else {
- for(i = 0; i < max_constantsF; i++) {
+ }
+ else
+ {
+ for (i = 0; i < max_constantsF; ++i)
+ {
DWORD idx, mask;
idx = i >> 5;
- mask = 1 << (i & 0x1f);
+ mask = 1u << (i & 0x1fu);
if (!shader_constant_is_local(shader, i) && (reg_maps->constf[idx] & mask))
{
shader_addline(buffer, "PARAM C%d = program.env[%d];\n",i, i);
@@ -1087,7 +1091,7 @@ static void shader_arb_get_register_name(const struct wined3d_shader_instruction
}
else
{
- if (ctx->cur_vs_args->super.swizzle_map & (1 << reg->idx[0].offset))
+ if (ctx->cur_vs_args->super.swizzle_map & (1u << reg->idx[0].offset))
*is_color = TRUE;
sprintf(register_name, "vertex.attrib[%u]", reg->idx[0].offset);
}
@@ -1426,14 +1430,14 @@ static void shader_hw_sample(const struct wined3d_shader_instruction *ins, DWORD
device = shader->device;
gl_info = &device->adapter->gl_info;
- if (pshader && priv->cur_ps_args->super.np2_fixup & (1 << sampler_idx)
+ if (pshader && priv->cur_ps_args->super.np2_fixup & (1u << sampler_idx)
&& gl_info->supported[ARB_TEXTURE_RECTANGLE])
tex_type = "RECT";
else
tex_type = "2D";
if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
{
- if (priv->cur_np2fixup_info->super.active & (1 << sampler_idx))
+ if (priv->cur_np2fixup_info->super.active & (1u << sampler_idx))
{
if (flags) FIXME("Only ordinary sampling from NP2 textures is supported.\n");
else np2_fixup = TRUE;
@@ -3220,7 +3224,7 @@ static void vshader_add_footer(struct shader_arb_ctx_priv *priv_ctx,
for (i = 0; i < gl_info->limits.clipplanes; ++i)
{
- if (args->clip.boolclip.clipplane_mask & (1 << i))
+ if (args->clip.boolclip.clipplane_mask & (1u << i))
{
shader_addline(buffer, "DP4 TA.%c, TMP_OUT, state.clip[%u].plane;\n",
component[cur_clip++], i);
@@ -3810,7 +3814,8 @@ static GLuint shader_arb_generate_pshader(const struct wined3d_shader *shader,
i, compiled->bumpenvmatconst[bump_const].const_num);
compiled->numbumpenvmatconsts = bump_const + 1;
- if (!(reg_maps->luminanceparams & (1 << i))) continue;
+ if (!(reg_maps->luminanceparams & (1u << i)))
+ continue;
compiled->luminanceconst[bump_const].const_num = next_local++;
shader_addline(buffer, "PARAM luminance%d = program.local[%d];\n",
@@ -3820,7 +3825,7 @@ static GLuint shader_arb_generate_pshader(const struct wined3d_shader *shader,
for(i = 0; i < MAX_CONST_I; i++)
{
compiled->int_consts[i] = WINED3D_CONST_NUM_UNUSED;
- if (reg_maps->integer_constants & (1 << i) && priv_ctx.target_version >= NV2)
+ if (reg_maps->integer_constants & (1u << i) && priv_ctx.target_version >= NV2)
{
const DWORD *control_values = find_loop_control_values(shader, i);
@@ -3876,13 +3881,18 @@ static GLuint shader_arb_generate_pshader(const struct wined3d_shader *shader,
fixup->offset = next_local;
fixup->super.active = 0;
- for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) {
- if (!(map & (1 << i))) continue;
+ for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
+ {
+ if (!(map & (1u << i)))
+ continue;
- if (fixup->offset + (cur_fixup_sampler >> 1) < max_lconsts) {
- fixup->super.active |= (1 << i);
+ if (fixup->offset + (cur_fixup_sampler >> 1) < max_lconsts)
+ {
+ fixup->super.active |= (1u << i);
fixup->super.idx[i] = cur_fixup_sampler++;
- } else {
+ }
+ else
+ {
FIXME("No free constant found to load NP2 fixup data into shader. "
"Sampling from this texture will probably look wrong.\n");
break;
@@ -4263,7 +4273,7 @@ static GLuint shader_arb_generate_vshader(const struct wined3d_shader *shader,
for(i = 0; i < MAX_CONST_I; i++)
{
compiled->int_consts[i] = WINED3D_CONST_NUM_UNUSED;
- if(reg_maps->integer_constants & (1 << i) && priv_ctx.target_version >= NV2)
+ if (reg_maps->integer_constants & (1u << i) && priv_ctx.target_version >= NV2)
{
const DWORD *control_values = find_loop_control_values(shader, i);
@@ -4536,7 +4546,7 @@ static void find_arb_ps_compile_args(const struct wined3d_state *state,
for(i = 0; i < MAX_CONST_B; i++)
{
if (state->ps_consts_b[i])
- args->bools |= ( 1 << i);
+ args->bools |= ( 1u << i);
}
/* Only enable the clip plane emulation KIL if at least one clipplane is enabled. The KIL instruction
@@ -4558,9 +4568,9 @@ static void find_arb_ps_compile_args(const struct wined3d_state *state,
return;
}
- for(i = 0; i < MAX_CONST_I; i++)
+ for (i = 0; i < MAX_CONST_I; ++i)
{
- if(int_skip & (1 << i))
+ if (int_skip & (1u << i))
{
args->loop_ctrl[i][0] = 0;
args->loop_ctrl[i][1] = 0;
@@ -4618,7 +4628,7 @@ static void find_arb_vs_compile_args(const struct wined3d_state *state,
for(i = 0; i < MAX_CONST_B; i++)
{
if (state->vs_consts_b[i])
- args->clip.boolclip.bools |= ( 1 << i);
+ args->clip.boolclip.bools |= (1u << i);
}
args->vertex.samplers[0] = context->tex_unit_map[MAX_FRAGMENT_SAMPLERS + 0];
@@ -4637,7 +4647,7 @@ static void find_arb_vs_compile_args(const struct wined3d_state *state,
for(i = 0; i < MAX_CONST_I; i++)
{
- if(int_skip & (1 << i))
+ if (int_skip & (1u << i))
{
args->loop_ctrl[i][0] = 0;
args->loop_ctrl[i][1] = 0;
@@ -4820,9 +4830,9 @@ static void shader_arb_disable(void *shader_priv, struct wined3d_context *contex
priv->last_vs_color_unclamp = FALSE;
}
- context->shader_update_mask = (1 << WINED3D_SHADER_TYPE_PIXEL)
- | (1 << WINED3D_SHADER_TYPE_VERTEX)
- | (1 << WINED3D_SHADER_TYPE_GEOMETRY);
+ context->shader_update_mask = (1u << WINED3D_SHADER_TYPE_PIXEL)
+ | (1u << WINED3D_SHADER_TYPE_VERTEX)
+ | (1u << WINED3D_SHADER_TYPE_GEOMETRY);
}
/* Context activation is done by the caller. */
@@ -5326,7 +5336,7 @@ static BOOL get_bool_const(const struct wined3d_shader_instruction *ins,
BOOL vshader = shader_is_vshader_version(reg_maps->shader_version.type);
const struct wined3d_shader_lconst *constant;
WORD bools = 0;
- WORD flag = (1 << idx);
+ WORD flag = (1u << idx);
struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
if (reg_maps->local_bool_consts & flag)
@@ -5358,7 +5368,7 @@ static void get_loop_control_const(const struct wined3d_shader_instruction *ins,
/* Integer constants can either be a local constant, or they can be stored in the shader
* type specific compile args. */
- if (reg_maps->local_int_consts & (1 << idx))
+ if (reg_maps->local_int_consts & (1u << idx))
{
const struct wined3d_shader_lconst *constant;
@@ -6611,7 +6621,7 @@ static void fragment_prog_arbfp(struct wined3d_context *context, const struct wi
}
else if (use_pshader)
{
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_PIXEL;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}
return;
}
@@ -6665,7 +6675,7 @@ static void fragment_prog_arbfp(struct wined3d_context *context, const struct wi
context->last_was_pshader = TRUE;
}
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_PIXEL;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}
/* We can't link the fog states to the fragment state directly since the
diff --git a/dlls/wined3d/buffer.c b/dlls/wined3d/buffer.c
index 40a137e..689bb5d 100644
--- a/dlls/wined3d/buffer.c
+++ b/dlls/wined3d/buffer.c
@@ -275,7 +275,7 @@ static BOOL buffer_check_attribute(struct wined3d_buffer *This, const struct win
/* Ignore attributes that do not have our vbo. After that check we can be sure that the attribute is
* there, on nonexistent attribs the vbo is 0.
*/
- if (!(si->use_map & (1 << attrib_idx))
+ if (!(si->use_map & (1u << attrib_idx))
|| state->streams[attrib->stream_idx].buffer != This)
return FALSE;
@@ -432,9 +432,9 @@ static inline void fixup_d3dcolor(DWORD *dst_color)
* 0x000000ff: Red mask
*/
*dst_color = 0;
- *dst_color |= (src_color & 0xff00ff00); /* Alpha Green */
- *dst_color |= (src_color & 0x00ff0000) >> 16; /* Red */
- *dst_color |= (src_color & 0x000000ff) << 16; /* Blue */
+ *dst_color |= (src_color & 0xff00ff00u); /* Alpha Green */
+ *dst_color |= (src_color & 0x00ff0000u) >> 16; /* Red */
+ *dst_color |= (src_color & 0x000000ffu) << 16; /* Blue */
}
static inline void fixup_transformed_pos(float *p)
diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c
index 79125d1..3e2a804 100644
--- a/dlls/wined3d/context.c
+++ b/dlls/wined3d/context.c
@@ -305,12 +305,12 @@ void context_check_fbo_status(const struct wined3d_context *context, GLenum targ
static inline DWORD context_generate_rt_mask(GLenum buffer)
{
/* Should take care of all the GL_FRONT/GL_BACK/GL_AUXi/GL_NONE... cases */
- return buffer ? (1 << 31) | buffer : 0;
+ return buffer ? (1u << 31) | buffer : 0;
}
static inline DWORD context_generate_rt_mask_from_surface(const struct wined3d_surface *target)
{
- return (1 << 31) | surface_get_gl_buffer(target);
+ return (1u << 31) | surface_get_gl_buffer(target);
}
static struct fbo_entry *context_create_fbo_entry(const struct wined3d_context *context,
@@ -1228,7 +1228,7 @@ void context_invalidate_state(struct wined3d_context *context, DWORD state)
context->dirtyArray[context->numDirtyEntries++] = rep;
idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
- context->isStateDirty[idx] |= (1 << shift);
+ context->isStateDirty[idx] |= (1u << shift);
}
/* This function takes care of wined3d pixel format selection. */
@@ -1805,9 +1805,9 @@ struct wined3d_context *context_create(struct wined3d_swapchain *swapchain,
GL_EXTCALL(glProvokingVertexEXT(GL_FIRST_VERTEX_CONVENTION_EXT));
}
device->shader_backend->shader_init_context_state(ret);
- ret->shader_update_mask = (1 << WINED3D_SHADER_TYPE_PIXEL)
- | (1 << WINED3D_SHADER_TYPE_VERTEX)
- | (1 << WINED3D_SHADER_TYPE_GEOMETRY);
+ ret->shader_update_mask = (1u << WINED3D_SHADER_TYPE_PIXEL)
+ | (1u << WINED3D_SHADER_TYPE_VERTEX)
+ | (1u << WINED3D_SHADER_TYPE_GEOMETRY);
/* If this happens to be the first context for the device, dummy textures
* are not created yet. In that case, they will be created (and bound) by
@@ -2099,12 +2099,12 @@ static void SetupForBlit(const struct wined3d_device *device, struct wined3d_con
static inline BOOL is_rt_mask_onscreen(DWORD rt_mask)
{
- return rt_mask & (1 << 31);
+ return rt_mask & (1u << 31);
}
static inline GLenum draw_buffer_from_rt_mask(DWORD rt_mask)
{
- return rt_mask & ~(1 << 31);
+ return rt_mask & ~(1u << 31);
}
/* Context activation is done by the caller. */
@@ -2387,7 +2387,7 @@ BOOL context_apply_clear_state(struct wined3d_context *context, const struct win
{
context->blit_targets[i] = wined3d_rendertarget_view_get_surface(rts[i]);
if (rts[i] && rts[i]->format->id != WINED3DFMT_NULL)
- rt_mask |= (1 << i);
+ rt_mask |= (1u << i);
}
while (i < context->gl_info->limits.buffers)
{
@@ -2423,7 +2423,7 @@ BOOL context_apply_clear_state(struct wined3d_context *context, const struct win
for (i = 0; i < rt_count; ++i)
{
if (rts[i] && rts[i]->format->id != WINED3DFMT_NULL)
- rt_mask |= (1 << i);
+ rt_mask |= (1u << i);
}
}
else
@@ -2482,9 +2482,9 @@ static DWORD find_draw_buffers_mask(const struct wined3d_context *context, const
i = 0;
while (rt_mask_bits)
{
- rt_mask_bits &= ~(1 << i);
+ rt_mask_bits &= ~(1u << i);
if (!rts[i] || rts[i]->format->id == WINED3DFMT_NULL)
- rt_mask &= ~(1 << i);
+ rt_mask &= ~(1u << i);
i++;
}
@@ -2581,11 +2581,11 @@ static void context_update_fixed_function_usage_map(struct wined3d_context *cont
|| ((alpha_arg2 == WINED3DTA_TEXTURE) && alpha_op != WINED3D_TOP_SELECT_ARG1)
|| ((alpha_arg3 == WINED3DTA_TEXTURE)
&& (alpha_op == WINED3D_TOP_MULTIPLY_ADD || alpha_op == WINED3D_TOP_LERP)))
- context->fixed_function_usage_map |= (1 << i);
+ context->fixed_function_usage_map |= (1u << i);
if ((color_op == WINED3D_TOP_BUMPENVMAP || color_op == WINED3D_TOP_BUMPENVMAP_LUMINANCE)
&& i < MAX_TEXTURES - 1)
- context->fixed_function_usage_map |= (1 << (i + 1));
+ context->fixed_function_usage_map |= (1u << (i + 1));
}
if (i < context->lowest_disabled_stage)
@@ -2688,7 +2688,7 @@ static BOOL context_unit_free_for_vs(const struct wined3d_context *context,
if (!ps_resource_info)
{
/* No pixel shader, check fixed function */
- return current_mapping >= MAX_TEXTURES || !(context->fixed_function_usage_map & (1 << current_mapping));
+ return current_mapping >= MAX_TEXTURES || !(context->fixed_function_usage_map & (1u << current_mapping));
}
/* Pixel shader, check the shader's sampler map */
@@ -2903,9 +2903,9 @@ void context_stream_info_from_declaration(struct wined3d_context *context,
if (!context->gl_info->supported[ARB_VERTEX_ARRAY_BGRA]
&& element->format->id == WINED3DFMT_B8G8R8A8_UNORM)
{
- stream_info->swizzle_map |= 1 << idx;
+ stream_info->swizzle_map |= 1u << idx;
}
- stream_info->use_map |= 1 << idx;
+ stream_info->use_map |= 1u << idx;
}
}
}
@@ -2983,9 +2983,9 @@ static void context_update_stream_info(struct wined3d_context *context, const st
}
else
{
- WORD slow_mask = -!d3d_info->ffp_generic_attributes & (1 << WINED3D_FFP_PSIZE);
+ WORD slow_mask = -!d3d_info->ffp_generic_attributes & (1u << WINED3D_FFP_PSIZE);
slow_mask |= -!gl_info->supported[ARB_VERTEX_ARRAY_BGRA]
- & ((1 << WINED3D_FFP_DIFFUSE) | (1 << WINED3D_FFP_SPECULAR));
+ & ((1u << WINED3D_FFP_DIFFUSE) | (1u << WINED3D_FFP_SPECULAR));
if (((stream_info->position_transformed && !d3d_info->xyzrhw)
|| (stream_info->use_map & slow_mask)) && !stream_info->all_vbo)
@@ -3201,7 +3201,7 @@ BOOL context_apply_draw_state(struct wined3d_context *context, struct wined3d_de
DWORD rep = context->dirtyArray[i];
DWORD idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
BYTE shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
- context->isStateDirty[idx] &= ~(1 << shift);
+ context->isStateDirty[idx] &= ~(1u << shift);
state_table[rep].apply(context, state, rep);
}
diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c
index 880f77c..f8b9666 100644
--- a/dlls/wined3d/device.c
+++ b/dlls/wined3d/device.c
@@ -1257,7 +1257,7 @@ HRESULT CDECL wined3d_device_set_stream_source(struct wined3d_device *device, UI
prev_buffer = stream->buffer;
if (device->recording)
- device->recording->changed.streamSource |= 1 << stream_idx;
+ device->recording->changed.streamSource |= 1u << stream_idx;
if (prev_buffer == buffer
&& stream->stride == stride
@@ -1338,7 +1338,7 @@ HRESULT CDECL wined3d_device_set_stream_source_freq(struct wined3d_device *devic
stream->frequency = divider & 0x7fffff;
if (device->recording)
- device->recording->changed.streamFreq |= 1 << stream_idx;
+ device->recording->changed.streamFreq |= 1u << stream_idx;
else if (stream->frequency != old_freq || stream->flags != old_flags)
wined3d_cs_emit_set_stream_source_freq(device->cs, stream_idx, stream->frequency, stream->flags);
@@ -1374,7 +1374,7 @@ void CDECL wined3d_device_set_transform(struct wined3d_device *device,
if (device->recording)
{
TRACE("Recording... not performing anything.\n");
- device->recording->changed.transform[d3dts >> 5] |= 1 << (d3dts & 0x1f);
+ device->recording->changed.transform[d3dts >> 5] |= 1u << (d3dts & 0x1f);
device->update_state->transforms[d3dts] = *matrix;
return;
}
@@ -1763,7 +1763,7 @@ HRESULT CDECL wined3d_device_set_clip_plane(struct wined3d_device *device,
}
if (device->recording)
- device->recording->changed.clipplane |= 1 << plane_idx;
+ device->recording->changed.clipplane |= 1u << plane_idx;
if (!memcmp(&device->update_state->clip_planes[plane_idx], plane, sizeof(*plane)))
{
@@ -1957,7 +1957,7 @@ void CDECL wined3d_device_set_render_state(struct wined3d_device *device,
if (device->recording)
{
TRACE("Recording... not performing anything.\n");
- device->recording->changed.renderState[state >> 5] |= 1 << (state & 0x1f);
+ device->recording->changed.renderState[state >> 5] |= 1u << (state & 0x1f);
return;
}
@@ -2005,7 +2005,7 @@ void CDECL wined3d_device_set_sampler_state(struct wined3d_device *device,
if (device->recording)
{
TRACE("Recording... not performing anything.\n");
- device->recording->changed.samplerState[sampler_idx] |= 1 << state;
+ device->recording->changed.samplerState[sampler_idx] |= 1u << state;
return;
}
@@ -2287,7 +2287,7 @@ HRESULT CDECL wined3d_device_set_vs_consts_b(struct wined3d_device *device,
if (device->recording)
{
for (i = start_register; i < count + start_register; ++i)
- device->recording->changed.vertexShaderConstantsB |= (1 << i);
+ device->recording->changed.vertexShaderConstantsB |= (1u << i);
}
else
{
@@ -2334,7 +2334,7 @@ HRESULT CDECL wined3d_device_set_vs_consts_i(struct wined3d_device *device,
if (device->recording)
{
for (i = start_register; i < count + start_register; ++i)
- device->recording->changed.vertexShaderConstantsI |= (1 << i);
+ device->recording->changed.vertexShaderConstantsI |= (1u << i);
}
else
{
@@ -2521,7 +2521,7 @@ HRESULT CDECL wined3d_device_set_ps_consts_b(struct wined3d_device *device,
if (device->recording)
{
for (i = start_register; i < count + start_register; ++i)
- device->recording->changed.pixelShaderConstantsB |= (1 << i);
+ device->recording->changed.pixelShaderConstantsB |= (1u << i);
}
else
{
@@ -2568,7 +2568,7 @@ HRESULT CDECL wined3d_device_set_ps_consts_i(struct wined3d_device *device,
if (device->recording)
{
for (i = start_register; i < count + start_register; ++i)
- device->recording->changed.pixelShaderConstantsI |= (1 << i);
+ device->recording->changed.pixelShaderConstantsI |= (1u << i);
}
else
{
@@ -2746,12 +2746,12 @@ static HRESULT process_vertices_strided(const struct wined3d_device *device, DWO
DWORD numTextures;
HRESULT hr;
- if (stream_info->use_map & (1 << WINED3D_FFP_NORMAL))
+ if (stream_info->use_map & (1u << WINED3D_FFP_NORMAL))
{
WARN(" lighting state not saved yet... Some strange stuff may happen !\n");
}
- if (!(stream_info->use_map & (1 << WINED3D_FFP_POSITION)))
+ if (!(stream_info->use_map & (1u << WINED3D_FFP_POSITION)))
{
ERR("Source has no position mask\n");
return WINED3DERR_INVALIDCALL;
@@ -2935,7 +2935,7 @@ static HRESULT process_vertices_strided(const struct wined3d_device *device, DWO
{
const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_DIFFUSE];
const DWORD *color_d = (const DWORD *)(element->data.addr + i * element->stride);
- if (!(stream_info->use_map & (1 << WINED3D_FFP_DIFFUSE)))
+ if (!(stream_info->use_map & (1u << WINED3D_FFP_DIFFUSE)))
{
static BOOL warned = FALSE;
@@ -2958,7 +2958,7 @@ static HRESULT process_vertices_strided(const struct wined3d_device *device, DWO
/* What's the color value in the feedback buffer? */
const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_SPECULAR];
const DWORD *color_s = (const DWORD *)(element->data.addr + i * element->stride);
- if (!(stream_info->use_map & (1 << WINED3D_FFP_SPECULAR)))
+ if (!(stream_info->use_map & (1u << WINED3D_FFP_SPECULAR)))
{
static BOOL warned = FALSE;
@@ -2980,7 +2980,7 @@ static HRESULT process_vertices_strided(const struct wined3d_device *device, DWO
{
const struct wined3d_stream_info_element *element = &stream_info->elements[WINED3D_FFP_TEXCOORD0 + tex_index];
const float *tex_coord = (const float *)(element->data.addr + i * element->stride);
- if (!(stream_info->use_map & (1 << (WINED3D_FFP_TEXCOORD0 + tex_index))))
+ if (!(stream_info->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + tex_index))))
{
ERR("No source texture, but destination requests one\n");
dest_ptr += GET_TEXCOORD_SIZE_FROM_FVF(DestFVF, tex_index) * sizeof(float);
@@ -3090,7 +3090,7 @@ void CDECL wined3d_device_set_texture_stage_state(struct wined3d_device *device,
if (device->recording)
{
TRACE("Recording... not performing anything.\n");
- device->recording->changed.textureState[stage] |= 1 << state;
+ device->recording->changed.textureState[stage] |= 1u << state;
return;
}
@@ -3143,7 +3143,7 @@ HRESULT CDECL wined3d_device_set_texture(struct wined3d_device *device,
}
if (device->recording)
- device->recording->changed.textures |= 1 << stage;
+ device->recording->changed.textures |= 1u << stage;
prev = device->update_state->textures[stage];
TRACE("Previous texture %p.\n", prev);
@@ -5095,7 +5095,7 @@ void device_invalidate_state(const struct wined3d_device *device, DWORD state)
context->dirtyArray[context->numDirtyEntries++] = rep;
idx = rep / (sizeof(*context->isStateDirty) * CHAR_BIT);
shift = rep & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
- context->isStateDirty[idx] |= (1 << shift);
+ context->isStateDirty[idx] |= (1u << shift);
}
}
diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c
index 019b415..5ac3ca7 100644
--- a/dlls/wined3d/directx.c
+++ b/dlls/wined3d/directx.c
@@ -3799,7 +3799,7 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter)
adapter->d3d_info.valid_rt_mask = 0;
for (i = 0; i < gl_info->limits.buffers; ++i)
- adapter->d3d_info.valid_rt_mask |= (1 << i);
+ adapter->d3d_info.valid_rt_mask |= (1u << i);
if (!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
{
diff --git a/dlls/wined3d/drawprim.c b/dlls/wined3d/drawprim.c
index 7a6a6e9..dcfebe4 100644
--- a/dlls/wined3d/drawprim.c
+++ b/dlls/wined3d/drawprim.c
@@ -139,13 +139,13 @@ static void drawStridedSlow(const struct wined3d_device *device, struct wined3d_
/* Start drawing in GL */
gl_info->gl_ops.gl.p_glBegin(glPrimType);
- if (si->use_map & (1 << WINED3D_FFP_POSITION))
+ if (si->use_map & (1u << WINED3D_FFP_POSITION))
{
element = &si->elements[WINED3D_FFP_POSITION];
position = element->data.addr;
}
- if (si->use_map & (1 << WINED3D_FFP_NORMAL))
+ if (si->use_map & (1u << WINED3D_FFP_NORMAL))
{
element = &si->elements[WINED3D_FFP_NORMAL];
normal = element->data.addr;
@@ -156,7 +156,7 @@ static void drawStridedSlow(const struct wined3d_device *device, struct wined3d_
}
num_untracked_materials = context->num_untracked_materials;
- if (si->use_map & (1 << WINED3D_FFP_DIFFUSE))
+ if (si->use_map & (1u << WINED3D_FFP_DIFFUSE))
{
element = &si->elements[WINED3D_FFP_DIFFUSE];
diffuse = element->data.addr;
@@ -169,7 +169,7 @@ static void drawStridedSlow(const struct wined3d_device *device, struct wined3d_
gl_info->gl_ops.gl.p_glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}
- if (si->use_map & (1 << WINED3D_FFP_SPECULAR))
+ if (si->use_map & (1u << WINED3D_FFP_SPECULAR))
{
element = &si->elements[WINED3D_FFP_SPECULAR];
specular = element->data.addr;
@@ -229,11 +229,11 @@ static void drawStridedSlow(const struct wined3d_device *device, struct wined3d_
continue;
}
- if (si->use_map & (1 << (WINED3D_FFP_TEXCOORD0 + coordIdx)))
+ if (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coordIdx)))
{
element = &si->elements[WINED3D_FFP_TEXCOORD0 + coordIdx];
texCoords[coordIdx] = element->data.addr;
- tex_mask |= (1 << textureNo);
+ tex_mask |= (1u << textureNo);
}
else
{
@@ -368,9 +368,9 @@ static inline void send_attribute(const struct wined3d_gl_info *gl_info,
if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA])
{
const DWORD *src = ptr;
- DWORD c = *src & 0xff00ff00;
- c |= (*src & 0xff0000) >> 16;
- c |= (*src & 0xff) << 16;
+ DWORD c = *src & 0xff00ff00u;
+ c |= (*src & 0xff0000u) >> 16;
+ c |= (*src & 0xffu) << 16;
GL_EXTCALL(glVertexAttrib4Nubv(index, (GLubyte *)&c));
break;
}
@@ -497,7 +497,7 @@ static void drawStridedSlowVs(struct wined3d_context *context, const struct wine
for (i = MAX_ATTRIBS - 1; i >= 0; i--)
{
- if (!(si->use_map & (1 << i))) continue;
+ if (!(si->use_map & (1u << i))) continue;
ptr = si->elements[i].data.addr + si->elements[i].stride * SkipnStrides;
@@ -534,7 +534,7 @@ static void drawStridedInstanced(struct wined3d_context *context, const struct w
for (i = 0; i < sizeof(si->elements) / sizeof(*si->elements); ++i)
{
- if (!(si->use_map & (1 << i))) continue;
+ if (!(si->use_map & (1u << i))) continue;
if (state->streams[si->elements[i].stream_idx].flags & WINED3DSTREAMSOURCE_INSTANCEDATA)
{
@@ -582,7 +582,7 @@ static void remove_vbos(struct wined3d_context *context,
{
struct wined3d_stream_info_element *e;
- if (!(s->use_map & (1 << i))) continue;
+ if (!(s->use_map & (1u << i))) continue;
e = &s->elements[i];
if (e->data.buffer_object)
diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c
index dd6f07f..6de70ba 100644
--- a/dlls/wined3d/glsl_shader.c
+++ b/dlls/wined3d/glsl_shader.c
@@ -1671,7 +1671,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
continue;
}
- shadow_sampler = version->type == WINED3D_SHADER_TYPE_PIXEL && (ps_args->shadow & (1 << entry->sampler_idx));
+ shadow_sampler = version->type == WINED3D_SHADER_TYPE_PIXEL && (ps_args->shadow & (1u << entry->sampler_idx));
switch (reg_maps->resource_info[entry->resource_idx].type)
{
case WINED3D_SHADER_RESOURCE_TEXTURE_1D:
@@ -1683,7 +1683,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
case WINED3D_SHADER_RESOURCE_TEXTURE_2D:
tex_rect = version->type == WINED3D_SHADER_TYPE_PIXEL
- && (ps_args->np2_fixup & (1 << entry->resource_idx))
+ && (ps_args->np2_fixup & (1u << entry->resource_idx))
&& gl_info->supported[ARB_TEXTURE_RECTANGLE];
if (shadow_sampler)
{
@@ -1738,7 +1738,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
for (i = 0; i < shader->limits->sampler; ++i)
{
- if (!reg_maps->resource_info[i].type || !(ps_args->np2_fixup & (1 << i)))
+ if (!reg_maps->resource_info[i].type || !(ps_args->np2_fixup & (1u << i)))
continue;
if (reg_maps->resource_info[i].type != WINED3D_SHADER_RESOURCE_TEXTURE_2D)
@@ -1823,7 +1823,7 @@ static void shader_generate_glsl_declarations(const struct wined3d_context *cont
shader_addline(buffer, "uniform mat2 bumpenv_mat%u;\n", i);
- if (reg_maps->luminanceparams & (1 << i))
+ if (reg_maps->luminanceparams & (1u << i))
{
shader_addline(buffer, "uniform float bumpenv_lum_scale%u;\n", i);
shader_addline(buffer, "uniform float bumpenv_lum_offset%u;\n", i);
@@ -2051,7 +2051,7 @@ static void shader_glsl_get_register_name(const struct wined3d_shader_register *
if (version->type == WINED3D_SHADER_TYPE_VERTEX)
{
struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
- if (priv->cur_vs_args->swizzle_map & (1 << reg->idx[0].offset))
+ if (priv->cur_vs_args->swizzle_map & (1u << reg->idx[0].offset))
*is_color = TRUE;
sprintf(register_name, "%s_in%u", prefix, reg->idx[0].offset);
break;
@@ -2539,7 +2539,7 @@ static void shader_glsl_get_sample_function(const struct wined3d_shader_context
enum wined3d_shader_resource_type resource_type = ctx->reg_maps->resource_info[resource_idx].type;
const struct wined3d_gl_info *gl_info = ctx->gl_info;
BOOL shadow = ctx->reg_maps->shader_version.type == WINED3D_SHADER_TYPE_PIXEL
- && (priv->cur_ps_args->shadow & (1 << resource_idx));
+ && (priv->cur_ps_args->shadow & (1u << resource_idx));
BOOL projected = flags & WINED3D_GLSL_SAMPLE_PROJECTED;
BOOL texrect = flags & WINED3D_GLSL_SAMPLE_NPOT && gl_info->supported[ARB_TEXTURE_RECTANGLE];
BOOL lod = flags & WINED3D_GLSL_SAMPLE_LOD;
@@ -2583,7 +2583,7 @@ static void shader_glsl_get_sample_function(const struct wined3d_shader_context
coord_size = resource_types[resource_type].coord_size;
if (shadow)
++coord_size;
- sample_function->coord_mask = (1 << coord_size) - 1;
+ sample_function->coord_mask = (1u << coord_size) - 1;
}
static void shader_glsl_release_sample_function(const struct wined3d_shader_context *ctx,
@@ -2720,7 +2720,7 @@ static void PRINTF_ATTR(8, 9) shader_glsl_gen_sample_code(const struct wined3d_s
const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
fixup = priv->cur_ps_args->color_fixup[sampler];
- if (priv->cur_ps_args->np2_fixup & (1 << sampler))
+ if (priv->cur_ps_args->np2_fixup & (1u << sampler))
np2_fixup = TRUE;
}
else
@@ -4006,7 +4006,7 @@ static void shader_glsl_tex(const struct wined3d_shader_instruction *ins)
}
}
- if (priv->cur_ps_args->np2_fixup & (1 << resource_idx))
+ if (priv->cur_ps_args->np2_fixup & (1u << resource_idx))
sample_flags |= WINED3D_GLSL_SAMPLE_NPOT;
shader_glsl_get_sample_function(ins->ctx, resource_idx, sample_flags, &sample_function);
@@ -4061,7 +4061,7 @@ static void shader_glsl_texldd(const struct wined3d_shader_instruction *ins)
}
sampler_idx = ins->src[1].reg.idx[0].offset;
- if (priv->cur_ps_args->np2_fixup & (1 << sampler_idx))
+ if (priv->cur_ps_args->np2_fixup & (1u << sampler_idx))
sample_flags |= WINED3D_GLSL_SAMPLE_NPOT;
shader_glsl_get_sample_function(ins->ctx, sampler_idx, sample_flags, &sample_function);
@@ -4086,7 +4086,7 @@ static void shader_glsl_texldl(const struct wined3d_shader_instruction *ins)
sampler_idx = ins->src[1].reg.idx[0].offset;
if (ins->ctx->reg_maps->shader_version.type == WINED3D_SHADER_TYPE_PIXEL
- && priv->cur_ps_args->np2_fixup & (1 << sampler_idx))
+ && priv->cur_ps_args->np2_fixup & (1u << sampler_idx))
sample_flags |= WINED3D_GLSL_SAMPLE_NPOT;
shader_glsl_get_sample_function(ins->ctx, sampler_idx, sample_flags, &sample_function);
@@ -4652,7 +4652,7 @@ static void shader_glsl_input_pack(const struct wined3d_shader *shader, struct w
char reg_mask[6];
/* Unused */
- if (!(reg_maps->input_registers & (1 << input->register_idx)))
+ if (!(reg_maps->input_registers & (1u << input->register_idx)))
continue;
semantic_name = input->semantic_name;
@@ -4776,7 +4776,7 @@ static void handle_ps3_input(struct shader_glsl_priv *priv,
{
const struct wined3d_shader_signature_element *input = &input_signature->elements[i];
- if (!(reg_maps_in->input_registers & (1 << input->register_idx)))
+ if (!(reg_maps_in->input_registers & (1u << input->register_idx)))
continue;
in_idx = map[input->register_idx];
@@ -4804,7 +4804,7 @@ static void handle_ps3_input(struct shader_glsl_priv *priv,
const struct wined3d_shader_signature_element *output = &output_signature->elements[j];
DWORD mask;
- if (!(reg_maps_out->output_registers & (1 << output->register_idx))
+ if (!(reg_maps_out->output_registers & (1u << output->register_idx))
|| input->semantic_idx != output->semantic_idx
|| strcmp(input->semantic_name, output->semantic_name)
|| !(mask = input->mask & output->mask))
@@ -4886,7 +4886,7 @@ static GLuint generate_param_reorder_function(struct shader_glsl_priv *priv,
const struct wined3d_shader_signature_element *output = &vs->output_signature.elements[i];
DWORD write_mask;
- if (!(vs->reg_maps.output_registers & (1 << output->register_idx)))
+ if (!(vs->reg_maps.output_registers & (1u << output->register_idx)))
continue;
semantic_name = output->semantic_name;
@@ -4946,7 +4946,7 @@ static GLuint generate_param_reorder_function(struct shader_glsl_priv *priv,
{
const struct wined3d_shader_signature_element *output = &vs->output_signature.elements[i];
- if (!(vs->reg_maps.output_registers & (1 << output->register_idx)))
+ if (!(vs->reg_maps.output_registers & (1u << output->register_idx)))
continue;
semantic_name = output->semantic_name;
@@ -5712,7 +5712,7 @@ static GLuint shader_glsl_generate_ffp_vertex_shader(struct wined3d_string_buffe
switch (settings->texgen[i] & 0xffff0000)
{
case WINED3DTSS_TCI_PASSTHRU:
- if (settings->texcoords & (1 << i))
+ if (settings->texcoords & (1u << i))
shader_addline(buffer, "gl_TexCoord[%u] = ffp_texture_matrix[%u] * ffp_attrib_texcoord%u;\n",
i, i, i);
break;
@@ -6063,7 +6063,7 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv *
if (arg0 == WINED3DTA_TEXTURE || arg1 == WINED3DTA_TEXTURE || arg2 == WINED3DTA_TEXTURE
|| (stage == 0 && settings->color_key_enabled))
- tex_map |= 1 << stage;
+ tex_map |= 1u << stage;
if (arg0 == WINED3DTA_TFACTOR || arg1 == WINED3DTA_TFACTOR || arg2 == WINED3DTA_TFACTOR)
tfactor_used = TRUE;
if (arg0 == WINED3DTA_TEMP || arg1 == WINED3DTA_TEMP || arg2 == WINED3DTA_TEMP)
@@ -6071,19 +6071,19 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv *
if (settings->op[stage].dst == tempreg)
tempreg_used = TRUE;
if (arg0 == WINED3DTA_CONSTANT || arg1 == WINED3DTA_CONSTANT || arg2 == WINED3DTA_CONSTANT)
- tss_const_map |= 1 << stage;
+ tss_const_map |= 1u << stage;
switch (settings->op[stage].cop)
{
case WINED3D_TOP_BUMPENVMAP_LUMINANCE:
- lum_map |= 1 << stage;
+ lum_map |= 1u << stage;
/* fall through */
case WINED3D_TOP_BUMPENVMAP:
- bump_map |= 1 << stage;
+ bump_map |= 1u << stage;
/* fall through */
case WINED3D_TOP_BLEND_TEXTURE_ALPHA:
case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM:
- tex_map |= 1 << stage;
+ tex_map |= 1u << stage;
break;
case WINED3D_TOP_BLEND_FACTOR_ALPHA:
@@ -6102,13 +6102,13 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv *
arg2 = settings->op[stage].aarg2 & WINED3DTA_SELECTMASK;
if (arg0 == WINED3DTA_TEXTURE || arg1 == WINED3DTA_TEXTURE || arg2 == WINED3DTA_TEXTURE)
- tex_map |= 1 << stage;
+ tex_map |= 1u << stage;
if (arg0 == WINED3DTA_TFACTOR || arg1 == WINED3DTA_TFACTOR || arg2 == WINED3DTA_TFACTOR)
tfactor_used = TRUE;
if (arg0 == WINED3DTA_TEMP || arg1 == WINED3DTA_TEMP || arg2 == WINED3DTA_TEMP)
tempreg_used = TRUE;
if (arg0 == WINED3DTA_CONSTANT || arg1 == WINED3DTA_CONSTANT || arg2 == WINED3DTA_CONSTANT)
- tss_const_map |= 1 << stage;
+ tss_const_map |= 1u << stage;
}
lowest_disabled_stage = stage;
@@ -6125,10 +6125,10 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv *
for (stage = 0; stage < MAX_TEXTURES; ++stage)
{
- if (tss_const_map & (1 << stage))
+ if (tss_const_map & (1u << stage))
shader_addline(buffer, "uniform vec4 tss_const%u;\n", stage);
- if (!(tex_map & (1 << stage)))
+ if (!(tex_map & (1u << stage)))
continue;
switch (settings->op[stage].tex_type)
@@ -6155,11 +6155,11 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv *
shader_addline(buffer, "vec4 tex%u;\n", stage);
- if (!(bump_map & (1 << stage)))
+ if (!(bump_map & (1u << stage)))
continue;
shader_addline(buffer, "uniform mat2 bumpenv_mat%u;\n", stage);
- if (!(lum_map & (1 << stage)))
+ if (!(lum_map & (1u << stage)))
continue;
shader_addline(buffer, "uniform float bumpenv_lum_scale%u;\n", stage);
shader_addline(buffer, "uniform float bumpenv_lum_offset%u;\n", stage);
@@ -6198,7 +6198,7 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv *
const char *texture_function, *coord_mask;
BOOL proj;
- if (!(tex_map & (1 << stage)))
+ if (!(tex_map & (1u << stage)))
continue;
if (settings->op[stage].projected == proj_none)
@@ -6631,7 +6631,7 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const
WORD attribs_map;
struct wined3d_string_buffer *tmp_name;
- if (!(context->shader_update_mask & (1 << WINED3D_SHADER_TYPE_VERTEX)) && ctx_data->glsl_program)
+ if (!(context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_VERTEX)) && ctx_data->glsl_program)
{
vs_id = ctx_data->glsl_program->vs.id;
vs_list = &ctx_data->glsl_program->vs.shader_entry;
@@ -6641,7 +6641,7 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const
vshader = state->shader[WINED3D_SHADER_TYPE_VERTEX];
gshader = state->shader[WINED3D_SHADER_TYPE_GEOMETRY];
- if (!(context->shader_update_mask & (1 << WINED3D_SHADER_TYPE_GEOMETRY))
+ if (!(context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_GEOMETRY))
&& ctx_data->glsl_program->gs.id)
gs_id = ctx_data->glsl_program->gs.id;
else if (gshader)
@@ -6671,7 +6671,7 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const
vs_list = &ffp_shader->linked_programs;
}
- if (!(context->shader_update_mask & (1 << WINED3D_SHADER_TYPE_PIXEL)) && ctx_data->glsl_program)
+ if (!(context->shader_update_mask & (1u << WINED3D_SHADER_TYPE_PIXEL)) && ctx_data->glsl_program)
{
ps_id = ctx_data->glsl_program->ps.id;
ps_list = &ctx_data->glsl_program->ps.shader_entry;
@@ -6748,7 +6748,7 @@ static void set_glsl_shader_program(const struct wined3d_context *context, const
}
else
{
- attribs_map = (1 << WINED3D_FFP_ATTRIBS_COUNT) - 1;
+ attribs_map = (1u << WINED3D_FFP_ATTRIBS_COUNT) - 1;
}
/* Bind vertex attributes to a corresponding index number to match
@@ -7114,9 +7114,9 @@ static void shader_glsl_invalidate_current_program(struct wined3d_context *conte
struct glsl_context_data *ctx_data = context->shader_backend_data;
ctx_data->glsl_program = NULL;
- context->shader_update_mask = (1 << WINED3D_SHADER_TYPE_PIXEL)
- | (1 << WINED3D_SHADER_TYPE_VERTEX)
- | (1 << WINED3D_SHADER_TYPE_GEOMETRY);
+ context->shader_update_mask = (1u << WINED3D_SHADER_TYPE_PIXEL)
+ | (1u << WINED3D_SHADER_TYPE_VERTEX)
+ | (1u << WINED3D_SHADER_TYPE_GEOMETRY);
}
/* Context activation is done by the caller. */
@@ -7803,7 +7803,7 @@ static void glsl_vertex_pipe_vp_free(struct wined3d_device *device)
static void glsl_vertex_pipe_shader(struct wined3d_context *context,
const struct wined3d_state *state, DWORD state_id)
{
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_VERTEX;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
}
static void glsl_vertex_pipe_vdecl(struct wined3d_context *context,
@@ -7820,7 +7820,7 @@ static void glsl_vertex_pipe_vdecl(struct wined3d_context *context,
* the draw uses the fixed function vertex pipeline regardless of any
* vertex shader set by the application. */
if (transformed != wasrhw)
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_VERTEX;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
if (!use_vs(state))
{
@@ -7836,12 +7836,12 @@ static void glsl_vertex_pipe_vdecl(struct wined3d_context *context,
* vertex shader on a vdecl change.
* TODO: Just always output all the texcoords when there are enough
* varyings available to drop the dependency. */
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_VERTEX;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
if (use_ps(state)
&& state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.shader_version.major == 1
&& state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.shader_version.minor <= 3)
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_PIXEL;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}
else
{
@@ -7859,7 +7859,7 @@ static void glsl_vertex_pipe_vdecl(struct wined3d_context *context,
static void glsl_vertex_pipe_vs(struct wined3d_context *context,
const struct wined3d_state *state, DWORD state_id)
{
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_VERTEX;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
/* Different vertex shaders potentially require a different vertex attributes setup. */
if (!isStateDirty(context, STATE_VDECL))
context_apply_state(context, state, STATE_VDECL);
@@ -7899,7 +7899,7 @@ static void glsl_vertex_pipe_projection(struct wined3d_context *context,
/* Table fog behavior depends on the projection matrix. */
if (state->render_states[WINED3D_RS_FOGENABLE]
&& state->render_states[WINED3D_RS_FOGTABLEMODE] != WINED3D_FOG_NONE)
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_VERTEX;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_PROJ;
}
@@ -7934,12 +7934,12 @@ static void glsl_vertex_pipe_texmatrix_np2(struct wined3d_context *context,
return;
if ((np2 = !(texture->flags & WINED3D_TEXTURE_POW2_MAT_IDENT))
- || context->lastWasPow2Texture & (1 << sampler))
+ || context->lastWasPow2Texture & (1u << sampler))
{
if (np2)
- context->lastWasPow2Texture |= 1 << sampler;
+ context->lastWasPow2Texture |= 1u << sampler;
else
- context->lastWasPow2Texture &= ~(1 << sampler);
+ context->lastWasPow2Texture &= ~(1u << sampler);
context->constant_update_mask |= WINED3D_SHADER_CONST_FFP_TEXMATRIX;
}
@@ -8226,7 +8226,7 @@ static void glsl_fragment_pipe_shader(struct wined3d_context *context,
{
context->last_was_pshader = use_ps(state);
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_PIXEL;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}
static void glsl_fragment_pipe_fogparams(struct wined3d_context *context,
@@ -8243,7 +8243,7 @@ static void glsl_fragment_pipe_fog(struct wined3d_context *context,
DWORD fogstart = state->render_states[WINED3D_RS_FOGSTART];
DWORD fogend = state->render_states[WINED3D_RS_FOGEND];
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_PIXEL;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
if (!state->render_states[WINED3D_RS_FOGENABLE])
return;
@@ -8279,7 +8279,7 @@ static void glsl_fragment_pipe_vdecl(struct wined3d_context *context,
static void glsl_fragment_pipe_tex_transform(struct wined3d_context *context,
const struct wined3d_state *state, DWORD state_id)
{
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_PIXEL;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}
static void glsl_fragment_pipe_invalidate_constants(struct wined3d_context *context,
diff --git a/dlls/wined3d/nvidia_texture_shader.c b/dlls/wined3d/nvidia_texture_shader.c
index 30d15ad..8c38fe2 100644
--- a/dlls/wined3d/nvidia_texture_shader.c
+++ b/dlls/wined3d/nvidia_texture_shader.c
@@ -41,9 +41,11 @@ static void nvts_activate_dimensions(const struct wined3d_state *state, DWORD st
|| state->texture_states[stage - 1][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP))
{
bumpmap = TRUE;
- context->texShaderBumpMap |= (1 << stage);
- } else {
- context->texShaderBumpMap &= ~(1 << stage);
+ context->texShaderBumpMap |= (1u << stage);
+ }
+ else
+ {
+ context->texShaderBumpMap &= ~(1u << stage);
}
if (state->textures[stage])
@@ -477,7 +479,7 @@ void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d
static void nvrc_colorop(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
- BOOL tex_used = context->fixed_function_usage_map & (1 << stage);
+ BOOL tex_used = context->fixed_function_usage_map & (1u << stage);
DWORD mapped_stage = context->tex_unit_map[stage];
const struct wined3d_gl_info *gl_info = context->gl_info;
@@ -570,7 +572,7 @@ static void nvrc_colorop(struct wined3d_context *context, const struct wined3d_s
{
BOOL usesBump = (state->texture_states[stage][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP_LUMINANCE
|| state->texture_states[stage][WINED3D_TSS_COLOR_OP] == WINED3D_TOP_BUMPENVMAP);
- BOOL usedBump = !!(context->texShaderBumpMap & 1 << (stage + 1));
+ BOOL usedBump = !!(context->texShaderBumpMap & 1u << (stage + 1));
if (usesBump != usedBump)
{
context_active_texture(context, gl_info, mapped_stage + 1);
diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c
index e9be51e..b7b57c7 100644
--- a/dlls/wined3d/shader.c
+++ b/dlls/wined3d/shader.c
@@ -499,7 +499,7 @@ static inline void set_bitmap_bit(DWORD *bitmap, DWORD bit)
DWORD idx, shift;
idx = bit >> 5;
shift = bit & 0x1f;
- bitmap[idx] |= (1 << shift);
+ bitmap[idx] |= (1u << shift);
}
static BOOL shader_record_register_usage(struct wined3d_shader *shader, struct wined3d_shader_reg_maps *reg_maps,
@@ -509,13 +509,13 @@ static BOOL shader_record_register_usage(struct wined3d_shader *shader, struct w
{
case WINED3DSPR_TEXTURE: /* WINED3DSPR_ADDR */
if (shader_type == WINED3D_SHADER_TYPE_PIXEL)
- reg_maps->texcoord |= 1 << reg->idx[0].offset;
+ reg_maps->texcoord |= 1u << reg->idx[0].offset;
else
- reg_maps->address |= 1 << reg->idx[0].offset;
+ reg_maps->address |= 1u << reg->idx[0].offset;
break;
case WINED3DSPR_TEMP:
- reg_maps->temporary |= 1 << reg->idx[0].offset;
+ reg_maps->temporary |= 1u << reg->idx[0].offset;
break;
case WINED3DSPR_INPUT:
@@ -538,7 +538,7 @@ static BOOL shader_record_register_usage(struct wined3d_shader *shader, struct w
}
}
else
- reg_maps->input_registers |= 1 << reg->idx[0].offset;
+ reg_maps->input_registers |= 1u << reg->idx[0].offset;
break;
case WINED3DSPR_RASTOUT:
@@ -589,7 +589,7 @@ static BOOL shader_record_register_usage(struct wined3d_shader *shader, struct w
}
else
{
- reg_maps->integer_constants |= (1 << reg->idx[0].offset);
+ reg_maps->integer_constants |= (1u << reg->idx[0].offset);
}
break;
@@ -601,12 +601,12 @@ static BOOL shader_record_register_usage(struct wined3d_shader *shader, struct w
}
else
{
- reg_maps->boolean_constants |= (1 << reg->idx[0].offset);
+ reg_maps->boolean_constants |= (1u << reg->idx[0].offset);
}
break;
case WINED3DSPR_COLOROUT:
- reg_maps->rt_mask |= (1 << reg->idx[0].offset);
+ reg_maps->rt_mask |= (1u << reg->idx[0].offset);
break;
default:
@@ -745,7 +745,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL && shader_version.major == 3
&& semantic->usage == WINED3D_DECL_USAGE_POSITION && !semantic->usage_idx)
return WINED3DERR_INVALIDCALL;
- reg_maps->input_registers |= 1 << reg_idx;
+ reg_maps->input_registers |= 1u << reg_idx;
shader_signature_from_semantic(&input_signature_elements[reg_idx], semantic);
break;
@@ -756,7 +756,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
ERR("Invalid output register index %u.\n", reg_idx);
break;
}
- reg_maps->output_registers |= 1 << reg_idx;
+ reg_maps->output_registers |= 1u << reg_idx;
shader_signature_from_semantic(&output_signature_elements[reg_idx], semantic);
if (semantic->usage == WINED3D_DECL_USAGE_FOG)
reg_maps->fog = 1;
@@ -853,7 +853,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
memcpy(lconst->value, ins.src[0].reg.immconst_data, 4 * sizeof(DWORD));
list_add_head(&shader->constantsI, &lconst->entry);
- reg_maps->local_int_consts |= (1 << lconst->idx);
+ reg_maps->local_int_consts |= (1u << lconst->idx);
}
else if (ins.handler_idx == WINED3DSIH_DEFB)
{
@@ -864,12 +864,12 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
memcpy(lconst->value, ins.src[0].reg.immconst_data, sizeof(DWORD));
list_add_head(&shader->constantsB, &lconst->entry);
- reg_maps->local_bool_consts |= (1 << lconst->idx);
+ reg_maps->local_bool_consts |= (1u << lconst->idx);
}
/* For subroutine prototypes. */
else if (ins.handler_idx == WINED3DSIH_LABEL)
{
- reg_maps->labels |= 1 << ins.src[0].reg.idx[0].offset;
+ reg_maps->labels |= 1u << ins.src[0].reg.idx[0].offset;
}
/* Set texture, address, temporary registers. */
else
@@ -902,19 +902,19 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
switch (idx)
{
case 0: /* oPos */
- reg_maps->output_registers |= 1 << 10;
+ reg_maps->output_registers |= 1u << 10;
shader_signature_from_usage(&output_signature_elements[10],
WINED3D_DECL_USAGE_POSITION, 0, 10, WINED3DSP_WRITEMASK_ALL);
break;
case 1: /* oFog */
- reg_maps->output_registers |= 1 << 11;
+ reg_maps->output_registers |= 1u << 11;
shader_signature_from_usage(&output_signature_elements[11],
WINED3D_DECL_USAGE_FOG, 0, 11, WINED3DSP_WRITEMASK_0);
break;
case 2: /* oPts */
- reg_maps->output_registers |= 1 << 11;
+ reg_maps->output_registers |= 1u << 11;
shader_signature_from_usage(&output_signature_elements[11],
WINED3D_DECL_USAGE_PSIZE, 0, 11, WINED3DSP_WRITEMASK_1);
break;
@@ -925,13 +925,13 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
if (idx < 2)
{
idx += 8;
- if (reg_maps->output_registers & (1 << idx))
+ if (reg_maps->output_registers & (1u << idx))
{
output_signature_elements[idx].mask |= ins.dst[i].write_mask;
}
else
{
- reg_maps->output_registers |= 1 << idx;
+ reg_maps->output_registers |= 1u << idx;
shader_signature_from_usage(&output_signature_elements[idx],
WINED3D_DECL_USAGE_COLOR, idx - 8, idx, ins.dst[i].write_mask);
}
@@ -941,13 +941,13 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
case WINED3DSPR_TEXCRDOUT:
reg_maps->texcoord_mask[idx] |= ins.dst[i].write_mask;
- if (reg_maps->output_registers & (1 << idx))
+ if (reg_maps->output_registers & (1u << idx))
{
output_signature_elements[idx].mask |= ins.dst[i].write_mask;
}
else
{
- reg_maps->output_registers |= 1 << idx;
+ reg_maps->output_registers |= 1u << idx;
shader_signature_from_usage(&output_signature_elements[idx],
WINED3D_DECL_USAGE_TEXCOORD, idx, idx, ins.dst[i].write_mask);
}
@@ -1012,16 +1012,16 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
if (ins.handler_idx == WINED3DSIH_TEXBEM
|| ins.handler_idx == WINED3DSIH_TEXBEML)
{
- reg_maps->bumpmat |= 1 << reg_idx;
+ reg_maps->bumpmat |= 1u << reg_idx;
if (ins.handler_idx == WINED3DSIH_TEXBEML)
{
- reg_maps->luminanceparams |= 1 << reg_idx;
+ reg_maps->luminanceparams |= 1u << reg_idx;
}
}
}
else if (ins.handler_idx == WINED3DSIH_BEM)
{
- reg_maps->bumpmat |= 1 << ins.dst[i].reg.idx[0].offset;
+ reg_maps->bumpmat |= 1u << ins.dst[i].reg.idx[0].offset;
}
}
@@ -1093,7 +1093,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
/* PS before 2.0 don't have explicit color outputs. Instead the value of
* R0 is written to the render target. */
if (shader_version.major < 2 && shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
- reg_maps->rt_mask |= (1 << 0);
+ reg_maps->rt_mask |= (1u << 0);
shader->functionLength = ((const char *)ptr - (const char *)byte_code);
@@ -1101,7 +1101,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
{
for (i = 0; i < input_signature->element_count; ++i)
{
- reg_maps->input_registers |= 1 << input_signature->elements[i].register_idx;
+ reg_maps->input_registers |= 1u << input_signature->elements[i].register_idx;
if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL
&& input_signature->elements[i].sysval_semantic == WINED3D_SV_POSITION)
reg_maps->vpos = 1;
@@ -1120,7 +1120,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
e = input_signature->elements;
for (i = 0; i < ARRAY_SIZE(input_signature_elements); ++i)
{
- if (!(reg_maps->input_registers & (1 << i)))
+ if (!(reg_maps->input_registers & (1u << i)))
continue;
input_signature_elements[i].register_idx = i;
*e++ = input_signature_elements[i];
@@ -1131,7 +1131,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
{
for (i = 0; i < output_signature->element_count; ++i)
{
- reg_maps->output_registers |= 1 << output_signature->elements[i].register_idx;
+ reg_maps->output_registers |= 1u << output_signature->elements[i].register_idx;
}
}
else if (reg_maps->output_registers)
@@ -1146,7 +1146,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
e = output_signature->elements;
for (i = 0; i < ARRAY_SIZE(output_signature_elements); ++i)
{
- if (!(reg_maps->output_registers & (1 << i)))
+ if (!(reg_maps->output_registers & (1u << i)))
continue;
*e++ = output_signature_elements[i];
}
@@ -1157,7 +1157,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, const st
unsigned int shader_find_free_input_register(const struct wined3d_shader_reg_maps *reg_maps, unsigned int max)
{
- DWORD map = 1 << max;
+ DWORD map = 1u << max;
map |= map - 1;
map &= reg_maps->shader_version.major < 3 ? ~reg_maps->texcoord : ~reg_maps->input_registers;
@@ -1924,9 +1924,9 @@ static void shader_none_disable(void *shader_priv, struct wined3d_context *conte
priv->vertex_pipe->vp_enable(gl_info, FALSE);
priv->fragment_pipe->enable_extension(gl_info, FALSE);
- context->shader_update_mask = (1 << WINED3D_SHADER_TYPE_PIXEL)
- | (1 << WINED3D_SHADER_TYPE_VERTEX)
- | (1 << WINED3D_SHADER_TYPE_GEOMETRY);
+ context->shader_update_mask = (1u << WINED3D_SHADER_TYPE_PIXEL)
+ | (1u << WINED3D_SHADER_TYPE_VERTEX)
+ | (1u << WINED3D_SHADER_TYPE_GEOMETRY);
}
static HRESULT shader_none_alloc(struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe,
@@ -2367,7 +2367,7 @@ static HRESULT vertexshader_init(struct wined3d_shader *shader, struct wined3d_d
{
const struct wined3d_shader_signature_element *input = &shader->input_signature.elements[i];
- if (!(reg_maps->input_registers & (1 << input->register_idx)) || !input->semantic_name)
+ if (!(reg_maps->input_registers & (1u << input->register_idx)) || !input->semantic_name)
continue;
shader->u.vs.attributes[input->register_idx].usage =
@@ -2520,11 +2520,11 @@ void find_ps_compile_args(const struct wined3d_state *state, const struct wined3
args->color_fixup[i] = texture->resource.format->color_fixup;
if (texture->resource.format_flags & WINED3DFMT_FLAG_SHADOW)
- args->shadow |= 1 << i;
+ args->shadow |= 1u << i;
/* Flag samplers that need NP2 texcoord fixup. */
if (!(texture->flags & WINED3D_TEXTURE_POW2_MAT_IDENT))
- args->np2_fixup |= (1 << i);
+ args->np2_fixup |= (1u << i);
}
if (shader->reg_maps.shader_version.major >= 3)
{
diff --git a/dlls/wined3d/shader_sm1.c b/dlls/wined3d/shader_sm1.c
index 0465002..1e6a7f2 100644
--- a/dlls/wined3d/shader_sm1.c
+++ b/dlls/wined3d/shader_sm1.c
@@ -31,62 +31,62 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
/* DCL usage masks */
#define WINED3DSP_DCL_USAGE_SHIFT 0
-#define WINED3DSP_DCL_USAGE_MASK (0xf << WINED3DSP_DCL_USAGE_SHIFT)
+#define WINED3DSP_DCL_USAGE_MASK (0xfu << WINED3DSP_DCL_USAGE_SHIFT)
#define WINED3DSP_DCL_USAGEINDEX_SHIFT 16
-#define WINED3DSP_DCL_USAGEINDEX_MASK (0xf << WINED3DSP_DCL_USAGEINDEX_SHIFT)
+#define WINED3DSP_DCL_USAGEINDEX_MASK (0xfu << WINED3DSP_DCL_USAGEINDEX_SHIFT)
/* DCL sampler type */
#define WINED3D_SM1_RESOURCE_TYPE_SHIFT 27
-#define WINED3D_SM1_RESOURCE_TYPE_MASK (0xf << WINED3D_SM1_RESOURCE_TYPE_SHIFT)
+#define WINED3D_SM1_RESOURCE_TYPE_MASK (0xfu << WINED3D_SM1_RESOURCE_TYPE_SHIFT)
/* Opcode-related masks */
#define WINED3DSI_OPCODE_MASK 0x0000ffff
#define WINED3D_OPCODESPECIFICCONTROL_SHIFT 16
-#define WINED3D_OPCODESPECIFICCONTROL_MASK (0xff << WINED3D_OPCODESPECIFICCONTROL_SHIFT)
+#define WINED3D_OPCODESPECIFICCONTROL_MASK (0xffu << WINED3D_OPCODESPECIFICCONTROL_SHIFT)
#define WINED3DSI_INSTLENGTH_SHIFT 24
-#define WINED3DSI_INSTLENGTH_MASK (0xf << WINED3DSI_INSTLENGTH_SHIFT)
+#define WINED3DSI_INSTLENGTH_MASK (0xfu << WINED3DSI_INSTLENGTH_SHIFT)
-#define WINED3DSI_COISSUE (1 << 30)
+#define WINED3DSI_COISSUE (0x1u << 30)
#define WINED3DSI_COMMENTSIZE_SHIFT 16
-#define WINED3DSI_COMMENTSIZE_MASK (0x7fff << WINED3DSI_COMMENTSIZE_SHIFT)
+#define WINED3DSI_COMMENTSIZE_MASK (0x7fffu << WINED3DSI_COMMENTSIZE_SHIFT)
-#define WINED3DSHADER_INSTRUCTION_PREDICATED (1 << 28)
+#define WINED3DSHADER_INSTRUCTION_PREDICATED (0x1u << 28)
/* Register number mask */
#define WINED3DSP_REGNUM_MASK 0x000007ff
/* Register type masks */
#define WINED3DSP_REGTYPE_SHIFT 28
-#define WINED3DSP_REGTYPE_MASK (0x7 << WINED3DSP_REGTYPE_SHIFT)
+#define WINED3DSP_REGTYPE_MASK (0x7u << WINED3DSP_REGTYPE_SHIFT)
#define WINED3DSP_REGTYPE_SHIFT2 8
-#define WINED3DSP_REGTYPE_MASK2 (0x18 << WINED3DSP_REGTYPE_SHIFT2)
+#define WINED3DSP_REGTYPE_MASK2 (0x18u << WINED3DSP_REGTYPE_SHIFT2)
/* Relative addressing mask */
#define WINED3DSHADER_ADDRESSMODE_SHIFT 13
-#define WINED3DSHADER_ADDRESSMODE_MASK (1 << WINED3DSHADER_ADDRESSMODE_SHIFT)
+#define WINED3DSHADER_ADDRESSMODE_MASK (0x1u << WINED3DSHADER_ADDRESSMODE_SHIFT)
/* Destination modifier mask */
#define WINED3DSP_DSTMOD_SHIFT 20
-#define WINED3DSP_DSTMOD_MASK (0xf << WINED3DSP_DSTMOD_SHIFT)
+#define WINED3DSP_DSTMOD_MASK (0xfu << WINED3DSP_DSTMOD_SHIFT)
/* Destination shift mask */
#define WINED3DSP_DSTSHIFT_SHIFT 24
-#define WINED3DSP_DSTSHIFT_MASK (0xf << WINED3DSP_DSTSHIFT_SHIFT)
+#define WINED3DSP_DSTSHIFT_MASK (0xfu << WINED3DSP_DSTSHIFT_SHIFT)
/* Write mask */
#define WINED3D_SM1_WRITEMASK_SHIFT 16
-#define WINED3D_SM1_WRITEMASK_MASK (0xf << WINED3D_SM1_WRITEMASK_SHIFT)
+#define WINED3D_SM1_WRITEMASK_MASK (0xfu << WINED3D_SM1_WRITEMASK_SHIFT)
/* Swizzle mask */
#define WINED3DSP_SWIZZLE_SHIFT 16
-#define WINED3DSP_SWIZZLE_MASK (0xff << WINED3DSP_SWIZZLE_SHIFT)
+#define WINED3DSP_SWIZZLE_MASK (0xffu << WINED3DSP_SWIZZLE_SHIFT)
/* Source modifier mask */
#define WINED3DSP_SRCMOD_SHIFT 24
-#define WINED3DSP_SRCMOD_MASK (0xf << WINED3DSP_SRCMOD_SHIFT)
+#define WINED3DSP_SRCMOD_MASK (0xfu << WINED3DSP_SRCMOD_SHIFT)
#define WINED3DSP_END 0x0000ffff
@@ -95,8 +95,8 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
enum WINED3DSHADER_ADDRESSMODE_TYPE
{
- WINED3DSHADER_ADDRMODE_ABSOLUTE = 0 << WINED3DSHADER_ADDRESSMODE_SHIFT,
- WINED3DSHADER_ADDRMODE_RELATIVE = 1 << WINED3DSHADER_ADDRESSMODE_SHIFT,
+ WINED3DSHADER_ADDRMODE_ABSOLUTE = 0u << WINED3DSHADER_ADDRESSMODE_SHIFT,
+ WINED3DSHADER_ADDRMODE_RELATIVE = 1u << WINED3DSHADER_ADDRESSMODE_SHIFT,
};
enum wined3d_sm1_resource_type
@@ -412,7 +412,7 @@ static int shader_get_param(const struct wined3d_sm1_data *priv, const DWORD *pt
{
if (priv->shader_version.major < 2)
{
- *addr_token = (1 << 31)
+ *addr_token = (1u << 31)
| ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT2) & WINED3DSP_REGTYPE_MASK2)
| ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT) & WINED3DSP_REGTYPE_MASK)
| (WINED3DSP_NOSWIZZLE << WINED3DSP_SWIZZLE_SHIFT);
diff --git a/dlls/wined3d/shader_sm4.c b/dlls/wined3d/shader_sm4.c
index 9f8fe12..e4d6336 100644
--- a/dlls/wined3d/shader_sm4.c
+++ b/dlls/wined3d/shader_sm4.c
@@ -24,47 +24,47 @@
WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
WINE_DECLARE_DEBUG_CHANNEL(d3d_bytecode);
-#define WINED3D_SM4_INSTRUCTION_MODIFIER (1 << 31)
+#define WINED3D_SM4_INSTRUCTION_MODIFIER (0x1u << 31)
#define WINED3D_SM4_INSTRUCTION_LENGTH_SHIFT 24
-#define WINED3D_SM4_INSTRUCTION_LENGTH_MASK (0x1f << WINED3D_SM4_INSTRUCTION_LENGTH_SHIFT)
+#define WINED3D_SM4_INSTRUCTION_LENGTH_MASK (0x1fu << WINED3D_SM4_INSTRUCTION_LENGTH_SHIFT)
#define WINED3D_SM4_RESOURCE_TYPE_SHIFT 11
-#define WINED3D_SM4_RESOURCE_TYPE_MASK (0xf << WINED3D_SM4_RESOURCE_TYPE_SHIFT)
+#define WINED3D_SM4_RESOURCE_TYPE_MASK (0xfu << WINED3D_SM4_RESOURCE_TYPE_SHIFT)
#define WINED3D_SM4_PRIMITIVE_TYPE_SHIFT 11
-#define WINED3D_SM4_PRIMITIVE_TYPE_MASK (0x7 << WINED3D_SM4_PRIMITIVE_TYPE_SHIFT)
+#define WINED3D_SM4_PRIMITIVE_TYPE_MASK (0x7u << WINED3D_SM4_PRIMITIVE_TYPE_SHIFT)
#define WINED3D_SM4_INDEX_TYPE_SHIFT 11
-#define WINED3D_SM4_INDEX_TYPE_MASK (0x1 << WINED3D_SM4_INDEX_TYPE_SHIFT)
+#define WINED3D_SM4_INDEX_TYPE_MASK (0x1u << WINED3D_SM4_INDEX_TYPE_SHIFT)
#define WINED3D_SM4_OPCODE_MASK 0xff
-#define WINED3D_SM4_REGISTER_MODIFIER (1 << 31)
+#define WINED3D_SM4_REGISTER_MODIFIER (0x1u << 31)
#define WINED3D_SM4_ADDRESSING_SHIFT1 25
-#define WINED3D_SM4_ADDRESSING_MASK1 (0x3 << WINED3D_SM4_ADDRESSING_SHIFT1)
+#define WINED3D_SM4_ADDRESSING_MASK1 (0x3u << WINED3D_SM4_ADDRESSING_SHIFT1)
#define WINED3D_SM4_ADDRESSING_SHIFT0 22
-#define WINED3D_SM4_ADDRESSING_MASK0 (0x3 << WINED3D_SM4_ADDRESSING_SHIFT0)
+#define WINED3D_SM4_ADDRESSING_MASK0 (0x3u << WINED3D_SM4_ADDRESSING_SHIFT0)
#define WINED3D_SM4_REGISTER_ORDER_SHIFT 20
-#define WINED3D_SM4_REGISTER_ORDER_MASK (0x3 << WINED3D_SM4_REGISTER_ORDER_SHIFT)
+#define WINED3D_SM4_REGISTER_ORDER_MASK (0x3u << WINED3D_SM4_REGISTER_ORDER_SHIFT)
#define WINED3D_SM4_REGISTER_TYPE_SHIFT 12
-#define WINED3D_SM4_REGISTER_TYPE_MASK (0xf << WINED3D_SM4_REGISTER_TYPE_SHIFT)
+#define WINED3D_SM4_REGISTER_TYPE_MASK (0xfu << WINED3D_SM4_REGISTER_TYPE_SHIFT)
#define WINED3D_SM4_SWIZZLE_TYPE_SHIFT 2
-#define WINED3D_SM4_SWIZZLE_TYPE_MASK (0x3 << WINED3D_SM4_SWIZZLE_TYPE_SHIFT)
+#define WINED3D_SM4_SWIZZLE_TYPE_MASK (0x3u << WINED3D_SM4_SWIZZLE_TYPE_SHIFT)
#define WINED3D_SM4_IMMCONST_TYPE_SHIFT 0
-#define WINED3D_SM4_IMMCONST_TYPE_MASK (0x3 << WINED3D_SM4_IMMCONST_TYPE_SHIFT)
+#define WINED3D_SM4_IMMCONST_TYPE_MASK (0x3u << WINED3D_SM4_IMMCONST_TYPE_SHIFT)
#define WINED3D_SM4_WRITEMASK_SHIFT 4
-#define WINED3D_SM4_WRITEMASK_MASK (0xf << WINED3D_SM4_WRITEMASK_SHIFT)
+#define WINED3D_SM4_WRITEMASK_MASK (0xfu << WINED3D_SM4_WRITEMASK_SHIFT)
#define WINED3D_SM4_SWIZZLE_SHIFT 4
-#define WINED3D_SM4_SWIZZLE_MASK (0xff << WINED3D_SM4_SWIZZLE_SHIFT)
+#define WINED3D_SM4_SWIZZLE_MASK (0xffu << WINED3D_SM4_SWIZZLE_SHIFT)
#define WINED3D_SM4_VERSION_MAJOR(version) (((version) >> 4) & 0xf)
#define WINED3D_SM4_VERSION_MINOR(version) (((version) >> 0) & 0xf)
diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c
index 3225aa6..2be3cab 100644
--- a/dlls/wined3d/state.c
+++ b/dlls/wined3d/state.c
@@ -587,7 +587,7 @@ void state_clipping(struct wined3d_context *context, const struct wined3d_state
* The enabled / disabled planes are hardcoded into the shader. Update the
* shader to update the enabled clipplanes. In case of fixed function, we
* need to update the clipping field from ffp_vertex_settings. */
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_VERTEX;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
/* TODO: Keep track of previously enabled clipplanes to avoid unnecessary resetting
* of already set values
@@ -1213,7 +1213,7 @@ static void state_colormat(struct wined3d_context *context, const struct wined3d
}
context->num_untracked_materials = 0;
- if ((context->stream_info.use_map & (1 << WINED3D_FFP_DIFFUSE))
+ if ((context->stream_info.use_map & (1u << WINED3D_FFP_DIFFUSE))
&& state->render_states[WINED3D_RS_COLORVERTEX])
{
TRACE("diff %d, amb %d, emis %d, spec %d\n",
@@ -1366,7 +1366,7 @@ static void state_normalize(struct wined3d_context *context, const struct wined3
* by zero and is not properly defined in opengl, so avoid it
*/
if (state->render_states[WINED3D_RS_NORMALIZENORMALS]
- && (context->stream_info.use_map & (1 << WINED3D_FFP_NORMAL)))
+ && (context->stream_info.use_map & (1u << WINED3D_FFP_NORMAL)))
{
gl_info->gl_ops.gl.p_glEnable(GL_NORMALIZE);
checkGLcall("glEnable(GL_NORMALIZE);");
@@ -2999,7 +2999,7 @@ static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined
static void tex_colorop(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
- BOOL tex_used = context->fixed_function_usage_map & (1 << stage);
+ BOOL tex_used = context->fixed_function_usage_map & (1u << stage);
DWORD mapped_stage = context->tex_unit_map[stage];
const struct wined3d_gl_info *gl_info = context->gl_info;
@@ -3060,7 +3060,7 @@ static void tex_colorop(struct wined3d_context *context, const struct wined3d_st
void tex_alphaop(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
- BOOL tex_used = context->fixed_function_usage_map & (1 << stage);
+ BOOL tex_used = context->fixed_function_usage_map & (1u << stage);
DWORD mapped_stage = context->tex_unit_map[stage];
const struct wined3d_gl_info *gl_info = context->gl_info;
DWORD op, arg1, arg2, arg0;
@@ -3213,7 +3213,7 @@ static void load_tex_coords(const struct wined3d_context *context, const struct
continue;
}
- if (coordIdx < MAX_TEXTURES && (si->use_map & (1 << (WINED3D_FFP_TEXCOORD0 + coordIdx))))
+ if (coordIdx < MAX_TEXTURES && (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coordIdx))))
{
const struct wined3d_stream_info_element *e = &si->elements[WINED3D_FFP_TEXCOORD0 + coordIdx];
@@ -3446,12 +3446,12 @@ static void sampler_texmatrix(struct wined3d_context *context, const struct wine
{
const BOOL texIsPow2 = !(texture->flags & WINED3D_TEXTURE_POW2_MAT_IDENT);
- if (texIsPow2 || (context->lastWasPow2Texture & (1 << sampler)))
+ if (texIsPow2 || (context->lastWasPow2Texture & (1u << sampler)))
{
if (texIsPow2)
- context->lastWasPow2Texture |= 1 << sampler;
+ context->lastWasPow2Texture |= 1u << sampler;
else
- context->lastWasPow2Texture &= ~(1 << sampler);
+ context->lastWasPow2Texture &= ~(1u << sampler);
transform_texture(context, state,
STATE_TEXTURESTAGE(context->tex_unit_map[sampler], WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS));
@@ -3667,12 +3667,12 @@ void apply_pixelshader(struct wined3d_context *context, const struct wined3d_sta
context->last_was_pshader = FALSE;
}
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_PIXEL;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}
static void state_geometry_shader(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_GEOMETRY;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_GEOMETRY;
}
static void shader_bumpenv(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
@@ -3927,7 +3927,7 @@ static inline void unload_numbered_array(struct wined3d_context *context, int i)
if (gl_info->supported[ARB_INSTANCED_ARRAYS])
GL_EXTCALL(glVertexAttribDivisor(i, 0));
- context->numbered_array_mask &= ~(1 << i);
+ context->numbered_array_mask &= ~(1u << i);
}
/* This should match any arrays loaded in loadNumberedArrays
@@ -3956,9 +3956,9 @@ static void load_numbered_arrays(struct wined3d_context *context,
{
const struct wined3d_stream_state *stream;
- if (!(stream_info->use_map & (1 << i)))
+ if (!(stream_info->use_map & (1u << i)))
{
- if (context->numbered_array_mask & (1 << i))
+ if (context->numbered_array_mask & (1u << i))
unload_numbered_array(context, i);
if (!use_vs(state) && i == WINED3D_FFP_DIFFUSE)
GL_EXTCALL(glVertexAttrib4f(i, 1.0f, 1.0f, 1.0f, 1.0f));
@@ -3980,7 +3980,7 @@ static void load_numbered_arrays(struct wined3d_context *context,
{
/* Unload instanced arrays, they will be loaded using
* immediate mode instead. */
- if (context->numbered_array_mask & (1 << i))
+ if (context->numbered_array_mask & (1u << i))
unload_numbered_array(context, i);
continue;
}
@@ -4005,10 +4005,10 @@ static void load_numbered_arrays(struct wined3d_context *context,
stream_info->elements[i].stride, stream_info->elements[i].data.addr
+ state->load_base_vertex_index * stream_info->elements[i].stride));
- if (!(context->numbered_array_mask & (1 << i)))
+ if (!(context->numbered_array_mask & (1u << i)))
{
GL_EXTCALL(glEnableVertexAttribArray(i));
- context->numbered_array_mask |= (1 << i);
+ context->numbered_array_mask |= (1u << i);
}
}
else
@@ -4023,7 +4023,7 @@ static void load_numbered_arrays(struct wined3d_context *context,
ptr += (ULONG_PTR)buffer_get_sysmem(stream->buffer, context);
}
- if (context->numbered_array_mask & (1 << i)) unload_numbered_array(context, i);
+ if (context->numbered_array_mask & (1u << i)) unload_numbered_array(context, i);
switch (stream_info->elements[i].format->id)
{
@@ -4047,9 +4047,9 @@ static void load_numbered_arrays(struct wined3d_context *context,
if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA])
{
const DWORD *src = (const DWORD *)ptr;
- DWORD c = *src & 0xff00ff00;
- c |= (*src & 0xff0000) >> 16;
- c |= (*src & 0xff) << 16;
+ DWORD c = *src & 0xff00ff00u;
+ c |= (*src & 0xff0000u) >> 16;
+ c |= (*src & 0xffu) << 16;
GL_EXTCALL(glVertexAttrib4Nubv(i, (GLubyte *)&c));
break;
}
@@ -4145,8 +4145,8 @@ static void load_vertex_data(struct wined3d_context *context,
context->instance_count = 0;
/* Blend Data ---------------------------------------------- */
- if ((si->use_map & (1 << WINED3D_FFP_BLENDWEIGHT))
- || si->use_map & (1 << WINED3D_FFP_BLENDINDICES))
+ if ((si->use_map & (1u << WINED3D_FFP_BLENDWEIGHT))
+ || si->use_map & (1u << WINED3D_FFP_BLENDINDICES))
{
e = &si->elements[WINED3D_FFP_BLENDWEIGHT];
@@ -4177,7 +4177,7 @@ static void load_vertex_data(struct wined3d_context *context,
checkGLcall("glWeightPointerARB");
- if (si->use_map & (1 << WINED3D_FFP_BLENDINDICES))
+ if (si->use_map & (1u << WINED3D_FFP_BLENDINDICES))
{
static BOOL warned;
if (!warned)
@@ -4204,7 +4204,7 @@ static void load_vertex_data(struct wined3d_context *context,
}
/* Point Size ----------------------------------------------*/
- if (si->use_map & (1 << WINED3D_FFP_PSIZE))
+ if (si->use_map & (1u << WINED3D_FFP_PSIZE))
{
/* no such functionality in the fixed function GL pipeline */
TRACE("Cannot change ptSize here in openGl\n");
@@ -4212,7 +4212,7 @@ static void load_vertex_data(struct wined3d_context *context,
}
/* Vertex Pointers -----------------------------------------*/
- if (si->use_map & (1 << WINED3D_FFP_POSITION))
+ if (si->use_map & (1u << WINED3D_FFP_POSITION))
{
e = &si->elements[WINED3D_FFP_POSITION];
@@ -4234,7 +4234,7 @@ static void load_vertex_data(struct wined3d_context *context,
}
/* Normals -------------------------------------------------*/
- if (si->use_map & (1 << WINED3D_FFP_NORMAL))
+ if (si->use_map & (1u << WINED3D_FFP_NORMAL))
{
e = &si->elements[WINED3D_FFP_NORMAL];
@@ -4261,7 +4261,7 @@ static void load_vertex_data(struct wined3d_context *context,
}
/* Diffuse Colour --------------------------------------------*/
- if (si->use_map & (1 << WINED3D_FFP_DIFFUSE))
+ if (si->use_map & (1u << WINED3D_FFP_DIFFUSE))
{
e = &si->elements[WINED3D_FFP_DIFFUSE];
@@ -4289,7 +4289,7 @@ static void load_vertex_data(struct wined3d_context *context,
}
/* Specular Colour ------------------------------------------*/
- if (si->use_map & (1 << WINED3D_FFP_SPECULAR))
+ if (si->use_map & (1u << WINED3D_FFP_SPECULAR))
{
TRACE("setting specular colour\n");
@@ -4520,7 +4520,7 @@ static void vertexdeclaration(struct wined3d_context *context, const struct wine
}
context->last_was_vshader = useVertexShaderFunction;
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_VERTEX;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_VERTEX;
if (updateFog)
context_apply_state(context, state, STATE_RENDER(WINED3D_RS_FOGVERTEXMODE));
@@ -4537,7 +4537,7 @@ static void vertexdeclaration(struct wined3d_context *context, const struct wine
if (use_ps(state) && state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.shader_version.major == 1
&& state->shader[WINED3D_SHADER_TYPE_PIXEL]->reg_maps.shader_version.minor <= 3)
- context->shader_update_mask |= 1 << WINED3D_SHADER_TYPE_PIXEL;
+ context->shader_update_mask |= 1u << WINED3D_SHADER_TYPE_PIXEL;
}
}
diff --git a/dlls/wined3d/stateblock.c b/dlls/wined3d/stateblock.c
index 763a5f9..cb3d494 100644
--- a/dlls/wined3d/stateblock.c
+++ b/dlls/wined3d/stateblock.c
@@ -225,7 +225,7 @@ fail:
static inline void stateblock_set_bits(DWORD *map, UINT map_size)
{
- DWORD mask = (1 << (map_size & 0x1f)) - 1;
+ DWORD mask = (1u << (map_size & 0x1f)) - 1;
memset(map, 0xff, (map_size >> 5) * sizeof(*map));
if (mask) map[map_size >> 5] = mask;
}
@@ -275,14 +275,14 @@ static void stateblock_savedstates_set_pixel(struct wined3d_saved_states *states
for (i = 0; i < sizeof(pixel_states_render) / sizeof(*pixel_states_render); ++i)
{
DWORD rs = pixel_states_render[i];
- states->renderState[rs >> 5] |= 1 << (rs & 0x1f);
+ states->renderState[rs >> 5] |= 1u << (rs & 0x1f);
}
for (i = 0; i < sizeof(pixel_states_texture) / sizeof(*pixel_states_texture); ++i)
- texture_mask |= 1 << pixel_states_texture[i];
+ texture_mask |= 1u << pixel_states_texture[i];
for (i = 0; i < MAX_TEXTURES; ++i) states->textureState[i] = texture_mask;
for (i = 0; i < sizeof(pixel_states_sampler) / sizeof(*pixel_states_sampler); ++i)
- sampler_mask |= 1 << pixel_states_sampler[i];
+ sampler_mask |= 1u << pixel_states_sampler[i];
for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i) states->samplerState[i] = sampler_mask;
states->pixelShaderConstantsB = 0xffff;
states->pixelShaderConstantsI = 0xffff;
@@ -302,14 +302,14 @@ static void stateblock_savedstates_set_vertex(struct wined3d_saved_states *state
for (i = 0; i < sizeof(vertex_states_render) / sizeof(*vertex_states_render); ++i)
{
DWORD rs = vertex_states_render[i];
- states->renderState[rs >> 5] |= 1 << (rs & 0x1f);
+ states->renderState[rs >> 5] |= 1u << (rs & 0x1f);
}
for (i = 0; i < sizeof(vertex_states_texture) / sizeof(*vertex_states_texture); ++i)
- texture_mask |= 1 << vertex_states_texture[i];
+ texture_mask |= 1u << vertex_states_texture[i];
for (i = 0; i < MAX_TEXTURES; ++i) states->textureState[i] = texture_mask;
for (i = 0; i < sizeof(vertex_states_sampler) / sizeof(*vertex_states_sampler); ++i)
- sampler_mask |= 1 << vertex_states_sampler[i];
+ sampler_mask |= 1u << vertex_states_sampler[i];
for (i = 0; i < MAX_COMBINED_SAMPLERS; ++i) states->samplerState[i] = sampler_mask;
states->vertexShaderConstantsB = 0xffff;
states->vertexShaderConstantsI = 0xffff;
@@ -357,7 +357,7 @@ void stateblock_init_contained_states(struct wined3d_stateblock *stateblock)
for (i = 0; i < MAX_CONST_I; ++i)
{
- if (stateblock->changed.vertexShaderConstantsI & (1 << i))
+ if (stateblock->changed.vertexShaderConstantsI & (1u << i))
{
stateblock->contained_vs_consts_i[stateblock->num_contained_vs_consts_i] = i;
++stateblock->num_contained_vs_consts_i;
@@ -366,7 +366,7 @@ void stateblock_init_contained_states(struct wined3d_stateblock *stateblock)
for (i = 0; i < MAX_CONST_B; ++i)
{
- if (stateblock->changed.vertexShaderConstantsB & (1 << i))
+ if (stateblock->changed.vertexShaderConstantsB & (1u << i))
{
stateblock->contained_vs_consts_b[stateblock->num_contained_vs_consts_b] = i;
++stateblock->num_contained_vs_consts_b;
@@ -384,7 +384,7 @@ void stateblock_init_contained_states(struct wined3d_stateblock *stateblock)
for (i = 0; i < MAX_CONST_I; ++i)
{
- if (stateblock->changed.pixelShaderConstantsI & (1 << i))
+ if (stateblock->changed.pixelShaderConstantsI & (1u << i))
{
stateblock->contained_ps_consts_i[stateblock->num_contained_ps_consts_i] = i;
++stateblock->num_contained_ps_consts_i;
@@ -393,7 +393,7 @@ void stateblock_init_contained_states(struct wined3d_stateblock *stateblock)
for (i = 0; i < MAX_CONST_B; ++i)
{
- if (stateblock->changed.pixelShaderConstantsB & (1 << i))
+ if (stateblock->changed.pixelShaderConstantsB & (1u << i))
{
stateblock->contained_ps_consts_b[stateblock->num_contained_ps_consts_b] = i;
++stateblock->num_contained_ps_consts_b;
diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c
index fc00823..f303d90 100644
--- a/dlls/wined3d/surface.c
+++ b/dlls/wined3d/surface.c
@@ -351,9 +351,9 @@ void draw_textured_quad(const struct wined3d_surface *src_surface, struct wined3
/* Works correctly only for <= 4 bpp formats. */
static void get_color_masks(const struct wined3d_format *format, DWORD *masks)
{
- masks[0] = ((1 << format->red_size) - 1) << format->red_offset;
- masks[1] = ((1 << format->green_size) - 1) << format->green_offset;
- masks[2] = ((1 << format->blue_size) - 1) << format->blue_offset;
+ masks[0] = ((1u << format->red_size) - 1) << format->red_offset;
+ masks[1] = ((1u << format->green_size) - 1) << format->green_offset;
+ masks[2] = ((1u << format->blue_size) - 1) << format->blue_offset;
}
static HRESULT surface_create_dib_section(struct wined3d_surface *surface)
@@ -388,7 +388,7 @@ static HRESULT surface_create_dib_section(struct wined3d_surface *surface)
default:
/* Allocate extra space for a palette. */
b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * (1 << (format->byte_count * 8)));
+ sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * (1u << (format->byte_count * 8)));
break;
}
@@ -2206,10 +2206,10 @@ static void convert_r5g6b5_x8r8g8b8(const BYTE *src, BYTE *dst,
for (x = 0; x < w; ++x)
{
WORD pixel = src_line[x];
- dst_line[x] = 0xff000000
- | convert_5to8[(pixel & 0xf800) >> 11] << 16
- | convert_6to8[(pixel & 0x07e0) >> 5] << 8
- | convert_5to8[(pixel & 0x001f)];
+ dst_line[x] = 0xff000000u
+ | convert_5to8[(pixel & 0xf800u) >> 11] << 16
+ | convert_6to8[(pixel & 0x07e0u) >> 5] << 8
+ | convert_5to8[(pixel & 0x001fu)];
}
}
}
diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c
index 5ff51ed..d31c285 100644
--- a/dlls/wined3d/utils.c
+++ b/dlls/wined3d/utils.c
@@ -283,8 +283,8 @@ static void convert_l4a4_unorm(const BYTE *src, BYTE *dst, UINT src_row_pitch, U
for (x = 0; x < width; x++ )
{
unsigned char color = (*Source++);
- /* A */ Dest[1] = (color & 0xf0) << 0;
- /* L */ Dest[0] = (color & 0x0f) << 4;
+ /* A */ Dest[1] = (color & 0xf0u) << 0;
+ /* L */ Dest[0] = (color & 0x0fu) << 4;
Dest += 2;
}
}
@@ -311,9 +311,9 @@ static void convert_r5g5_snorm_l6_unorm(const BYTE *src, BYTE *dst, UINT src_row
texel_in = (const unsigned short *)(src + z * src_slice_pitch + y * src_row_pitch);
for (x = 0; x < width; x++ )
{
- l_in = (*texel_in & 0xfc00) >> 10;
- g_in = (*texel_in & 0x03e0) >> 5;
- r_in = *texel_in & 0x001f;
+ l_in = (*texel_in & 0xfc00u) >> 10;
+ g_in = (*texel_in & 0x03e0u) >> 5;
+ r_in = *texel_in & 0x001fu;
*texel_out = ((r_in + 16) << 11) | (l_in << 5) | (g_in + 16);
texel_out++;
@@ -338,9 +338,9 @@ static void convert_r5g5_snorm_l6_unorm_ext(const BYTE *src, BYTE *dst, UINT src
texel_out = dst + z * dst_slice_pitch + y * dst_row_pitch;
for (x = 0; x < width; x++ )
{
- l_in = (*texel_in & 0xfc00) >> 10;
- g_in = (*texel_in & 0x03e0) >> 5;
- r_in = *texel_in & 0x001f;
+ l_in = (*texel_in & 0xfc00u) >> 10;
+ g_in = (*texel_in & 0x03e0u) >> 5;
+ r_in = *texel_in & 0x001fu;
r_out = r_in << 3;
if (!(r_in & 0x10)) /* r > 0 */
@@ -385,9 +385,9 @@ static void convert_r5g5_snorm_l6_unorm_nv(const BYTE *src, BYTE *dst, UINT src_
texel_out = dst + z * dst_slice_pitch + y * dst_row_pitch;
for (x = 0; x < width; x++ )
{
- l_in = (*texel_in & 0xfc00) >> 10;
- g_in = (*texel_in & 0x03e0) >> 5;
- r_in = *texel_in & 0x001f;
+ l_in = (*texel_in & 0xfc00u) >> 10;
+ g_in = (*texel_in & 0x03e0u) >> 5;
+ r_in = *texel_in & 0x001fu;
ds_out = r_in << 3;
if (!(r_in & 0x10)) /* r > 0 */
@@ -657,7 +657,7 @@ static void convert_s8_uint_d24_float(const BYTE *src, BYTE *dst, UINT src_row_p
for (x = 0; x < width; ++x)
{
- dest_f[x * 2] = float_24_to_32((source[x] & 0xffffff00) >> 8);
+ dest_f[x * 2] = float_24_to_32((source[x] & 0xffffff00u) >> 8);
dest_s[x * 2 + 1] = source[x] & 0xff;
}
}
@@ -724,9 +724,9 @@ static void convert_b5g6r5_unorm_b5g5r5a1_unorm_color_key(const BYTE *src, unsig
{
WORD src_color = src_row[x];
if (!color_in_range(color_key, src_color))
- dst_row[x] = 0x8000 | ((src_color & 0xffc0) >> 1) | (src_color & 0x1f);
+ dst_row[x] = 0x8000u | ((src_color & 0xffc0u) >> 1) | (src_color & 0x1fu);
else
- dst_row[x] = ((src_color & 0xffc0) >> 1) | (src_color & 0x1f);
+ dst_row[x] = ((src_color & 0xffc0u) >> 1) | (src_color & 0x1fu);
}
}
}
@@ -1875,10 +1875,10 @@ static void check_fbo_compat(struct wined3d_caps_gl_ctx *ctx, struct wined3d_for
checkGLcall("Post-pixelshader blending check");
a = color >> 24;
- r = (color & 0x00ff0000) >> 16;
+ r = (color & 0x00ff0000u) >> 16;
- r_range = format->red_size < 8 ? 1 << (8 - format->red_size) : 1;
- a_range = format->alpha_size < 8 ? 1 << (8 - format->alpha_size) : 1;
+ r_range = format->red_size < 8 ? 1u << (8 - format->red_size) : 1;
+ a_range = format->alpha_size < 8 ? 1u << (8 - format->alpha_size) : 1;
if (format->red_size && (r < 0x7f - r_range || r > 0x7f + r_range))
match = FALSE;
else if (format->alpha_size > 1 && (a < 0xbf - a_range || a > 0xbf + a_range))
@@ -2735,7 +2735,7 @@ float wined3d_adapter_find_polyoffset_scale(struct wined3d_caps_gl_ctx *ctx, GLe
if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
{
FIXME("No FBOs, assuming polyoffset scale of 2^%u.\n", fallback);
- return (float)(1 << fallback);
+ return (float)(1u << fallback);
}
gl_info->gl_ops.gl.p_glGenTextures(1, &color);
@@ -2773,7 +2773,7 @@ float wined3d_adapter_find_polyoffset_scale(struct wined3d_caps_gl_ctx *ctx, GLe
gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* The post viewport transform Z of the geometry runs from 0.0 to 0.5. We want to push it another
* 0.25 so that the Z buffer content (0.5) cuts the quad off at half the screen. */
- gl_info->gl_ops.gl.p_glPolygonOffset(0.0f, (float)(1 << cur) * 0.25f);
+ gl_info->gl_ops.gl.p_glPolygonOffset(0.0f, (float)(1u << cur) * 0.25f);
draw_test_quad(ctx, geometry, &blue);
checkGLcall("Test draw");
@@ -2804,7 +2804,7 @@ float wined3d_adapter_find_polyoffset_scale(struct wined3d_caps_gl_ctx *ctx, GLe
gl_info->gl_ops.gl.p_glDisable(GL_DEPTH_TEST);
gl_info->gl_ops.gl.p_glDisable(GL_POLYGON_OFFSET_FILL);
- return (float)(1 << cur);
+ return (float)(1u << cur);
}
const struct wined3d_format *wined3d_get_format(const struct wined3d_gl_info *gl_info,
@@ -3883,12 +3883,12 @@ void get_texture_matrix(const struct wined3d_context *context, const struct wine
compute_texture_matrix(gl_info, &state->transforms[WINED3D_TS_TEXTURE0 + tex],
state->texture_states[tex][WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS],
generated, context->last_was_rhw,
- context->stream_info.use_map & (1 << (WINED3D_FFP_TEXCOORD0 + coord_idx))
+ context->stream_info.use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx))
? context->stream_info.elements[WINED3D_FFP_TEXCOORD0 + coord_idx].format->id
: WINED3DFMT_UNKNOWN,
device->shader_backend->shader_has_ffp_proj_control(device->shader_priv), mat);
- if ((context->lastWasPow2Texture & (1 << tex)) && state->textures[tex])
+ if ((context->lastWasPow2Texture & (1u << tex)) && state->textures[tex])
{
if (generated)
FIXME("Non-power-of-two texture being used with generated texture coords.\n");
@@ -4145,7 +4145,7 @@ DWORD wined3d_format_convert_from_float(const struct wined3d_surface *surface, c
static float color_to_float(DWORD color, DWORD size, DWORD offset)
{
- DWORD mask = (1 << size) - 1;
+ DWORD mask = (1u << size) - 1;
if (!size)
return 1.0f;
@@ -4792,7 +4792,7 @@ void wined3d_ffp_get_vs_settings(const struct wined3d_state *state, const struct
settings->transformed = 1;
settings->point_size = state->gl_primitive_type == GL_POINTS;
- settings->per_vertex_point_size = !!(si->use_map & 1 << WINED3D_FFP_PSIZE);
+ settings->per_vertex_point_size = !!(si->use_map & 1u << WINED3D_FFP_PSIZE);
if (!state->render_states[WINED3D_RS_FOGENABLE])
settings->fog_mode = WINED3D_FFP_VS_FOG_OFF;
else if (state->render_states[WINED3D_RS_FOGTABLEMODE] != WINED3D_FOG_NONE)
@@ -4803,8 +4803,8 @@ void wined3d_ffp_get_vs_settings(const struct wined3d_state *state, const struct
for (i = 0; i < MAX_TEXTURES; ++i)
{
coord_idx = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
- if (coord_idx < MAX_TEXTURES && (si->use_map & (1 << (WINED3D_FFP_TEXCOORD0 + coord_idx))))
- settings->texcoords |= 1 << i;
+ if (coord_idx < MAX_TEXTURES && (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx))))
+ settings->texcoords |= 1u << i;
settings->texgen[i] = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
}
return;
@@ -4826,14 +4826,14 @@ void wined3d_ffp_get_vs_settings(const struct wined3d_state *state, const struct
settings->transformed = 0;
settings->clipping = state->render_states[WINED3D_RS_CLIPPING]
&& state->render_states[WINED3D_RS_CLIPPLANEENABLE];
- settings->normal = !!(si->use_map & (1 << WINED3D_FFP_NORMAL));
+ settings->normal = !!(si->use_map & (1u << WINED3D_FFP_NORMAL));
settings->normalize = settings->normal && state->render_states[WINED3D_RS_NORMALIZENORMALS];
settings->lighting = !!state->render_states[WINED3D_RS_LIGHTING];
settings->localviewer = !!state->render_states[WINED3D_RS_LOCALVIEWER];
settings->point_size = state->gl_primitive_type == GL_POINTS;
- settings->per_vertex_point_size = !!(si->use_map & 1 << WINED3D_FFP_PSIZE);
+ settings->per_vertex_point_size = !!(si->use_map & 1u << WINED3D_FFP_PSIZE);
- if (state->render_states[WINED3D_RS_COLORVERTEX] && (si->use_map & (1 << WINED3D_FFP_DIFFUSE)))
+ if (state->render_states[WINED3D_RS_COLORVERTEX] && (si->use_map & (1u << WINED3D_FFP_DIFFUSE)))
{
settings->diffuse_source = state->render_states[WINED3D_RS_DIFFUSEMATERIALSOURCE];
settings->emissive_source = state->render_states[WINED3D_RS_EMISSIVEMATERIALSOURCE];
@@ -4852,8 +4852,8 @@ void wined3d_ffp_get_vs_settings(const struct wined3d_state *state, const struct
for (i = 0; i < MAX_TEXTURES; ++i)
{
coord_idx = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
- if (coord_idx < MAX_TEXTURES && (si->use_map & (1 << (WINED3D_FFP_TEXCOORD0 + coord_idx))))
- settings->texcoords |= 1 << i;
+ if (coord_idx < MAX_TEXTURES && (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx))))
+ settings->texcoords |= 1u << i;
settings->texgen[i] = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
}
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index 7847557..d1ba5e4 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -127,10 +127,10 @@ static inline struct color_fixup_desc create_complex_fixup_desc(enum complex_fix
{
struct color_fixup_desc fixup =
{
- 0, complex_fixup & (1 << 0) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
- 0, complex_fixup & (1 << 1) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
- 0, complex_fixup & (1 << 2) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
- 0, complex_fixup & (1 << 3) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
+ 0u, complex_fixup & (1u << 0) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
+ 0u, complex_fixup & (1u << 1) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
+ 0u, complex_fixup & (1u << 2) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
+ 0u, complex_fixup & (1u << 3) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
};
return fixup;
}
@@ -156,10 +156,10 @@ static inline BOOL is_same_fixup(struct color_fixup_desc f1, struct color_fixup_
static inline enum complex_fixup get_complex_fixup(struct color_fixup_desc fixup)
{
enum complex_fixup complex_fixup = 0;
- if (fixup.x_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1 << 0);
- if (fixup.y_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1 << 1);
- if (fixup.z_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1 << 2);
- if (fixup.w_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1 << 3);
+ if (fixup.x_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1u << 0);
+ if (fixup.y_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1u << 1);
+ if (fixup.z_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1u << 2);
+ if (fixup.w_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1u << 3);
return complex_fixup;
}
@@ -214,9 +214,9 @@ static inline GLenum wined3d_gl_min_mip_filter(enum wined3d_texture_filter_type
*/
static inline float float_16_to_32(const unsigned short *in)
{
- const unsigned short s = ((*in) & 0x8000);
- const unsigned short e = ((*in) & 0x7c00) >> 10;
- const unsigned short m = (*in) & 0x3ff;
+ const unsigned short s = ((*in) & 0x8000u);
+ const unsigned short e = ((*in) & 0x7c00u) >> 10;
+ const unsigned short m = (*in) & 0x3ffu;
const float sgn = (s ? -1.0f : 1.0f);
if(e == 0) {
@@ -232,9 +232,9 @@ static inline float float_16_to_32(const unsigned short *in)
static inline float float_24_to_32(DWORD in)
{
- const float sgn = in & 0x800000 ? -1.0f : 1.0f;
- const unsigned short e = (in & 0x780000) >> 19;
- const unsigned int m = in & 0x7ffff;
+ const float sgn = in & 0x800000u ? -1.0f : 1.0f;
+ const unsigned short e = (in & 0x780000u) >> 19;
+ const unsigned int m = in & 0x7ffffu;
if (e == 0)
{
@@ -364,7 +364,7 @@ enum wined3d_immconst_type
WINED3D_IMMCONST_VEC4,
};
-#define WINED3DSP_NOSWIZZLE (0 | (1 << 2) | (2 << 4) | (3 << 6))
+#define WINED3DSP_NOSWIZZLE (0u | (1u << 2) | (2u << 4) | (3u << 6))
enum wined3d_shader_src_modifier
{
@@ -384,11 +384,11 @@ enum wined3d_shader_src_modifier
WINED3DSPSM_NOT = 13,
};
-#define WINED3DSP_WRITEMASK_0 0x1 /* .x r */
-#define WINED3DSP_WRITEMASK_1 0x2 /* .y g */
-#define WINED3DSP_WRITEMASK_2 0x4 /* .z b */
-#define WINED3DSP_WRITEMASK_3 0x8 /* .w a */
-#define WINED3DSP_WRITEMASK_ALL 0xf /* all */
+#define WINED3DSP_WRITEMASK_0 0x1u /* .x r */
+#define WINED3DSP_WRITEMASK_1 0x2u /* .y g */
+#define WINED3DSP_WRITEMASK_2 0x4u /* .z b */
+#define WINED3DSP_WRITEMASK_3 0x8u /* .w a */
+#define WINED3DSP_WRITEMASK_ALL 0xfu /* all */
enum wined3d_shader_dst_modifier
{
@@ -413,11 +413,11 @@ enum wined3d_shader_rel_op
WINED3D_SHADER_REL_OP_LE = 6,
};
-#define WINED3D_SM1_VS 0xfffe
-#define WINED3D_SM1_PS 0xffff
-#define WINED3D_SM4_PS 0x0000
-#define WINED3D_SM4_VS 0x0001
-#define WINED3D_SM4_GS 0x0002
+#define WINED3D_SM1_VS 0xfffeu
+#define WINED3D_SM1_PS 0xffffu
+#define WINED3D_SM4_PS 0x0000u
+#define WINED3D_SM4_VS 0x0001u
+#define WINED3D_SM4_GS 0x0002u
/* Shader version tokens, and shader end tokens */
#define WINED3DPS_VERSION(major, minor) ((WINED3D_SM1_PS << 16) | ((major) << 8) | (minor))
@@ -810,11 +810,11 @@ enum wined3d_ffp_ps_fog_mode
* into the shader code
*/
-#define WINED3D_PSARGS_PROJECTED (1 << 3)
+#define WINED3D_PSARGS_PROJECTED (1u << 3)
#define WINED3D_PSARGS_TEXTRANSFORM_SHIFT 4
-#define WINED3D_PSARGS_TEXTRANSFORM_MASK 0xf
+#define WINED3D_PSARGS_TEXTRANSFORM_MASK 0xfu
#define WINED3D_PSARGS_TEXTYPE_SHIFT 2
-#define WINED3D_PSARGS_TEXTYPE_MASK 0x3
+#define WINED3D_PSARGS_TEXTYPE_MASK 0x3u
/* Used for Shader Model 1 pixel shaders to track the bound texture
* type. 2D and RECT textures are separated through NP2 fixup. */
@@ -1897,10 +1897,10 @@ enum wined3d_ffp_vs_fog_mode
};
#define WINED3D_FFP_TCI_SHIFT 16
-#define WINED3D_FFP_TCI_MASK 0xff
+#define WINED3D_FFP_TCI_MASK 0xffu
#define WINED3D_FFP_LIGHT_TYPE_SHIFT(idx) (3 * (idx))
-#define WINED3D_FFP_LIGHT_TYPE_MASK 0x7
+#define WINED3D_FFP_LIGHT_TYPE_MASK 0x7u
struct wined3d_ffp_vs_settings
{
@@ -2128,7 +2128,7 @@ static inline BOOL isStateDirty(const struct wined3d_context *context, DWORD sta
{
DWORD idx = state / (sizeof(*context->isStateDirty) * CHAR_BIT);
BYTE shift = state & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
- return context->isStateDirty[idx] & (1 << shift);
+ return context->isStateDirty[idx] & (1u << shift);
}
#define WINED3D_RESOURCE_ACCESS_GPU 0x1
@@ -3255,6 +3255,6 @@ static inline void context_apply_state(struct wined3d_context *context,
/* The WNDCLASS-Name for the fake window which we use to retrieve the GL capabilities */
#define WINED3D_OPENGL_WINDOW_CLASS_NAME "WineD3D_OpenGL"
-#define MAKEDWORD_VERSION(maj, min) (((maj & 0xffff) << 16) | (min & 0xffff))
+#define MAKEDWORD_VERSION(maj, min) (((maj & 0xffffu) << 16) | (min & 0xffffu))
#endif
diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h
index a07c9ef..4d28bab 100644
--- a/include/wine/wined3d.h
+++ b/include/wine/wined3d.h
@@ -724,9 +724,9 @@ struct wined3d_query_data_timestamp_disjoint
BOOL disjoint;
};
-#define WINED3DISSUE_BEGIN (1 << 1)
-#define WINED3DISSUE_END (1 << 0)
-#define WINED3DGETDATA_FLUSH (1 << 0)
+#define WINED3DISSUE_BEGIN (1u << 1)
+#define WINED3DISSUE_END (1u << 0)
+#define WINED3DGETDATA_FLUSH (1u << 0)
enum wined3d_stateblock_type
{
@@ -797,10 +797,10 @@ enum wined3d_display_rotation
WINED3D_DISPLAY_ROTATION_270 = 4,
};
-#define WINED3DCOLORWRITEENABLE_RED (1 << 0)
-#define WINED3DCOLORWRITEENABLE_GREEN (1 << 1)
-#define WINED3DCOLORWRITEENABLE_BLUE (1 << 2)
-#define WINED3DCOLORWRITEENABLE_ALPHA (1 << 3)
+#define WINED3DCOLORWRITEENABLE_RED (1u << 0)
+#define WINED3DCOLORWRITEENABLE_GREEN (1u << 1)
+#define WINED3DCOLORWRITEENABLE_BLUE (1u << 2)
+#define WINED3DCOLORWRITEENABLE_ALPHA (1u << 3)
#define WINED3DADAPTER_DEFAULT 0
#define WINED3DENUM_NO_WHQL_LEVEL 2
@@ -875,12 +875,12 @@ enum wined3d_display_rotation
#define WINED3DPRESENT_INTERVAL_IMMEDIATE 0x80000000
#define WINED3DMAXUSERCLIPPLANES 32
-#define WINED3DCLIPPLANE0 (1 << 0)
-#define WINED3DCLIPPLANE1 (1 << 1)
-#define WINED3DCLIPPLANE2 (1 << 2)
-#define WINED3DCLIPPLANE3 (1 << 3)
-#define WINED3DCLIPPLANE4 (1 << 4)
-#define WINED3DCLIPPLANE5 (1 << 5)
+#define WINED3DCLIPPLANE0 (1u << 0)
+#define WINED3DCLIPPLANE1 (1u << 1)
+#define WINED3DCLIPPLANE2 (1u << 2)
+#define WINED3DCLIPPLANE3 (1u << 3)
+#define WINED3DCLIPPLANE4 (1u << 4)
+#define WINED3DCLIPPLANE5 (1u << 5)
/* FVF (Flexible Vertex Format) codes */
#define WINED3DFVF_RESERVED0 0x0001
@@ -912,10 +912,10 @@ enum wined3d_display_rotation
#define WINED3DFVF_LASTBETA_D3DCOLOR 0x8000
#define WINED3DFVF_RESERVED2 0x6000
-#define WINED3DFVF_TEXTUREFORMAT1 3
-#define WINED3DFVF_TEXTUREFORMAT2 0
-#define WINED3DFVF_TEXTUREFORMAT3 1
-#define WINED3DFVF_TEXTUREFORMAT4 2
+#define WINED3DFVF_TEXTUREFORMAT1 3u
+#define WINED3DFVF_TEXTUREFORMAT2 0u
+#define WINED3DFVF_TEXTUREFORMAT3 1u
+#define WINED3DFVF_TEXTUREFORMAT4 2u
#define WINED3DFVF_TEXCOORDSIZE1(idx) (WINED3DFVF_TEXTUREFORMAT1 << (idx * 2 + 16))
#define WINED3DFVF_TEXCOORDSIZE2(idx) (WINED3DFVF_TEXTUREFORMAT2 << (idx * 2 + 16))
#define WINED3DFVF_TEXCOORDSIZE3(idx) (WINED3DFVF_TEXTUREFORMAT3 << (idx * 2 + 16))
@@ -927,8 +927,8 @@ enum wined3d_display_rotation
#define WINED3DCLEAR_STENCIL 0x00000004
/* Stream source flags */
-#define WINED3DSTREAMSOURCE_INDEXEDDATA (1 << 30)
-#define WINED3DSTREAMSOURCE_INSTANCEDATA (2 << 30)
+#define WINED3DSTREAMSOURCE_INDEXEDDATA (1u << 30)
+#define WINED3DSTREAMSOURCE_INSTANCEDATA (2u << 30)
/* SetPrivateData flags */
#define WINED3DSPD_IUNKNOWN 0x00000001
--
2.1.4
More information about the wine-patches
mailing list