diff --git a/dlls/wined3d/buffer.c b/dlls/wined3d/buffer.c index 6d44c2e85815f9e4baa9bb7216817341b4911033..a6b79ec6a8095aed868fd3883738a8ba25baaef7 100644 --- a/dlls/wined3d/buffer.c +++ b/dlls/wined3d/buffer.c @@ -287,11 +287,9 @@ static BOOL buffer_process_converted_attribute(struct wined3d_buffer *This, static BOOL buffer_check_attribute(struct wined3d_buffer *This, const struct wined3d_stream_info *si, UINT attrib_idx, const BOOL check_d3dcolor, const BOOL is_ffp_position, const BOOL is_ffp_color, - DWORD *stride_this_run, BOOL *float16_used) + DWORD *stride_this_run) { const struct wined3d_stream_info_element *attrib = &si->elements[attrib_idx]; - IWineD3DDeviceImpl *device = This->resource.device; - const struct wined3d_gl_info *gl_info = &device->adapter->gl_info; enum wined3d_format_id format; BOOL ret = FALSE; @@ -304,16 +302,7 @@ static BOOL buffer_check_attribute(struct wined3d_buffer *This, const struct win format = attrib->format->id; /* Look for newly appeared conversion */ - if (!gl_info->supported[ARB_HALF_FLOAT_VERTEX] - && (format == WINED3DFMT_R16G16_FLOAT || format == WINED3DFMT_R16G16B16A16_FLOAT)) - { - ret = buffer_process_converted_attribute(This, CONV_FLOAT16_2, attrib, stride_this_run); - - if (is_ffp_position) FIXME("Test FLOAT16 fixed function processing positions\n"); - else if (is_ffp_color) FIXME("test FLOAT16 fixed function processing colors\n"); - *float16_used = TRUE; - } - else if (check_d3dcolor && format == WINED3DFMT_B8G8R8A8_UNORM) + if (check_d3dcolor && format == WINED3DFMT_B8G8R8A8_UNORM) { ret = buffer_process_converted_attribute(This, CONV_D3DCOLOR, attrib, stride_this_run); @@ -331,71 +320,6 @@ static BOOL buffer_check_attribute(struct wined3d_buffer *This, const struct win return ret; } -static UINT *find_conversion_shift(struct wined3d_buffer *This, - const struct wined3d_stream_info *strided, UINT stride) -{ - UINT *ret, i, j, shift, orig_type_size; - - if (!stride) - { - TRACE("No shift\n"); - return NULL; - } - - This->conversion_stride = stride; - ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DWORD) * stride); - for (i = 0; i < MAX_ATTRIBS; ++i) - { - enum wined3d_format_id format; - - if (!(strided->use_map & (1 << i)) || strided->elements[i].buffer_object != This->buffer_object) continue; - - format = strided->elements[i].format->id; - if (format == WINED3DFMT_R16G16_FLOAT) - { - shift = 4; - } - else if (format == WINED3DFMT_R16G16B16A16_FLOAT) - { - shift = 8; - /* Pre-shift the last 4 bytes in the FLOAT16_4 by 4 bytes - this makes FLOAT16_2 and FLOAT16_4 conversions - * compatible - */ - for (j = 4; j < 8; ++j) - { - ret[(DWORD_PTR)strided->elements[i].data + j] += 4; - } - } - else - { - shift = 0; - } - This->conversion_stride += shift; - - if (shift) - { - orig_type_size = strided->elements[i].format->component_count - * strided->elements[i].format->component_size; - for (j = (DWORD_PTR)strided->elements[i].data + orig_type_size; j < stride; ++j) - { - ret[j] += shift; - } - } - } - - if (TRACE_ON(d3d)) - { - TRACE("Dumping conversion shift:\n"); - for (i = 0; i < stride; ++i) - { - TRACE("[%d]", ret[i]); - } - TRACE("\n"); - } - - return ret; -} - static BOOL buffer_find_decl(struct wined3d_buffer *This) { IWineD3DDeviceImpl *device = This->resource.device; @@ -403,9 +327,8 @@ static BOOL buffer_find_decl(struct wined3d_buffer *This) const struct wined3d_stream_info *si = &device->strided_streams; const struct wined3d_state *state = &device->stateBlock->state; UINT stride_this_run = 0; - BOOL float16_used = FALSE; BOOL ret = FALSE; - unsigned int i; + BOOL support_d3dcolor = gl_info->supported[ARB_VERTEX_ARRAY_BGRA]; /* In d3d7 the vertex buffer declaration NEVER changes because it is stored in the d3d7 vertex buffer. * Once we have our declaration there is no need to look it up again. Index buffers also never need @@ -416,6 +339,20 @@ static BOOL buffer_find_decl(struct wined3d_buffer *This) if(This->resource.usage & WINED3DUSAGE_STATICDECL) return FALSE; } + if (use_vs(state)) + { + TRACE("Vertex shaders used, no VBO conversion is needed\n"); + if(This->conversion_map) + { + HeapFree(GetProcessHeap(), 0, This->conversion_map); + This->conversion_map = NULL; + This->stride = 0; + return TRUE; + } + + return FALSE; + } + TRACE("Finding vertex buffer conversion information\n"); /* Certain declaration types need some fixups before we can pass them to * opengl. This means D3DCOLOR attributes with fixed function vertex @@ -461,79 +398,31 @@ static BOOL buffer_find_decl(struct wined3d_buffer *This) * conversion types depend on the semantic as well, for example a FLOAT4 * texcoord needs no conversion while a FLOAT4 positiont needs one */ - if (use_vs(state)) - { - TRACE("vshader\n"); - /* If the current vertex declaration is marked for no half float conversion don't bother to - * analyse the strided streams in depth, just set them up for no conversion. Return decl changed - * if we used conversion before - */ - if (!state->vertex_declaration->half_float_conv_needed) - { - if (This->conversion_map) - { - TRACE("Now using shaders without conversion, but conversion used before\n"); - HeapFree(GetProcessHeap(), 0, This->conversion_map); - HeapFree(GetProcessHeap(), 0, This->conversion_shift); - This->conversion_map = NULL; - This->stride = 0; - This->conversion_shift = NULL; - This->conversion_stride = 0; - return TRUE; - } - else - { - return FALSE; - } - } - for (i = 0; i < MAX_ATTRIBS; ++i) - { - ret = buffer_check_attribute(This, si, i, FALSE, FALSE, FALSE, &stride_this_run, &float16_used) || ret; - } - /* Recalculate the conversion shift map if the declaration has changed, - * and we're using float16 conversion or used it on the last run - */ - if (ret && (float16_used || This->conversion_map)) - { - HeapFree(GetProcessHeap(), 0, This->conversion_shift); - This->conversion_shift = find_conversion_shift(This, si, This->stride); - } - } - else - { - /* Fixed function is a bit trickier. We have to take care for D3DCOLOR types, FLOAT4 positions and of course - * FLOAT16s if not supported. Also, we can't iterate over the array, so use macros to generate code for all - * the attributes that our current fixed function pipeline implementation cares for. - */ - BOOL support_d3dcolor = gl_info->supported[ARB_VERTEX_ARRAY_BGRA]; - ret = buffer_check_attribute(This, si, WINED3D_FFP_POSITION, - TRUE, TRUE, FALSE, &stride_this_run, &float16_used) || ret; - ret = buffer_check_attribute(This, si, WINED3D_FFP_NORMAL, - TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret; - ret = buffer_check_attribute(This, si, WINED3D_FFP_DIFFUSE, - !support_d3dcolor, FALSE, TRUE, &stride_this_run, &float16_used) || ret; - ret = buffer_check_attribute(This, si, WINED3D_FFP_SPECULAR, - !support_d3dcolor, FALSE, TRUE, &stride_this_run, &float16_used) || ret; - ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD0, - TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret; - ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD1, - TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret; - ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD2, - TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret; - ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD3, - TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret; - ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD4, - TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret; - ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD5, - TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret; - ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD6, - TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret; - ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD7, - TRUE, FALSE, FALSE, &stride_this_run, &float16_used) || ret; - - if (float16_used) FIXME("Float16 conversion used with fixed function vertex processing\n"); - } + ret = buffer_check_attribute(This, si, WINED3D_FFP_POSITION, + TRUE, TRUE, FALSE, &stride_this_run) || ret; + ret = buffer_check_attribute(This, si, WINED3D_FFP_NORMAL, + TRUE, FALSE, FALSE, &stride_this_run) || ret; + ret = buffer_check_attribute(This, si, WINED3D_FFP_DIFFUSE, + !support_d3dcolor, FALSE, TRUE, &stride_this_run) || ret; + ret = buffer_check_attribute(This, si, WINED3D_FFP_SPECULAR, + !support_d3dcolor, FALSE, TRUE, &stride_this_run) || ret; + ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD0, + TRUE, FALSE, FALSE, &stride_this_run) || ret; + ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD1, + TRUE, FALSE, FALSE, &stride_this_run) || ret; + ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD2, + TRUE, FALSE, FALSE, &stride_this_run) || ret; + ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD3, + TRUE, FALSE, FALSE, &stride_this_run) || ret; + ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD4, + TRUE, FALSE, FALSE, &stride_this_run) || ret; + ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD5, + TRUE, FALSE, FALSE, &stride_this_run) || ret; + ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD6, + TRUE, FALSE, FALSE, &stride_this_run) || ret; + ret = buffer_check_attribute(This, si, WINED3D_FFP_TEXCOORD7, + TRUE, FALSE, FALSE, &stride_this_run) || ret; if (!stride_this_run && This->conversion_map) { @@ -549,36 +438,6 @@ static BOOL buffer_find_decl(struct wined3d_buffer *This) return ret; } -/* Context activation is done by the caller. */ -static void buffer_check_buffer_object_size(struct wined3d_buffer *This, const struct wined3d_gl_info *gl_info) -{ - UINT size = This->conversion_stride ? - This->conversion_stride * (This->resource.size / This->stride) : This->resource.size; - if (This->buffer_object_size != size) - { - TRACE("Old size %u, creating new size %u\n", This->buffer_object_size, size); - - if(This->buffer_type_hint == GL_ELEMENT_ARRAY_BUFFER_ARB) - { - IWineD3DDeviceImpl_MarkStateDirty(This->resource.device, STATE_INDEXBUFFER); - } - - /* Rescue the data before resizing the buffer object if we do not have our backup copy */ - if(!(This->flags & WINED3D_BUFFER_DOUBLEBUFFER)) - { - buffer_get_sysmem(This, gl_info); - } - - ENTER_GL(); - GL_EXTCALL(glBindBufferARB(This->buffer_type_hint, This->buffer_object)); - checkGLcall("glBindBufferARB"); - GL_EXTCALL(glBufferDataARB(This->buffer_type_hint, size, NULL, This->buffer_object_usage)); - This->buffer_object_size = size; - checkGLcall("glBufferDataARB"); - LEAVE_GL(); - } -} - static inline void fixup_d3dcolor(DWORD *dst_color) { DWORD src_color = *dst_color; @@ -694,8 +553,6 @@ static void buffer_unload(struct wined3d_resource *resource) context_release(context); - HeapFree(GetProcessHeap(), 0, buffer->conversion_shift); - buffer->conversion_shift = NULL; HeapFree(GetProcessHeap(), 0, buffer->conversion_map); buffer->conversion_map = NULL; buffer->stride = 0; @@ -981,7 +838,6 @@ void CDECL wined3d_buffer_preload(struct wined3d_buffer *buffer) IWineD3DDeviceImpl_MarkStateDirty(device, STATE_STREAMSRC); goto end; } - buffer_check_buffer_object_size(buffer, gl_info); /* The declaration changed, reload the whole buffer */ WARN("Reloading buffer because of decl change\n"); @@ -1057,20 +913,16 @@ void CDECL wined3d_buffer_preload(struct wined3d_buffer *buffer) /* Now for each vertex in the buffer that needs conversion */ vertices = buffer->resource.size / buffer->stride; - if (buffer->conversion_shift) - { - TRACE("Shifted conversion\n"); - data = HeapAlloc(GetProcessHeap(), 0, vertices * buffer->conversion_stride); + data = HeapAlloc(GetProcessHeap(), 0, buffer->resource.size); - start = 0; - len = buffer->resource.size; + while(buffer->modified_areas) + { + buffer->modified_areas--; + start = buffer->maps[buffer->modified_areas].offset; + len = buffer->maps[buffer->modified_areas].size; end = start + len; - if (buffer->maps[0].offset || buffer->maps[0].size != buffer->resource.size) - { - FIXME("Implement partial buffer load with shifted conversion\n"); - } - + memcpy(data + start, buffer->resource.allocatedMemory + start, end - start); for (i = start / buffer->stride; i < min((end / buffer->stride) + 1, vertices); ++i) { for (j = 0; j < buffer->stride; ++j) @@ -1078,24 +930,20 @@ void CDECL wined3d_buffer_preload(struct wined3d_buffer *buffer) switch (buffer->conversion_map[j]) { case CONV_NONE: - data[buffer->conversion_stride * i + j + buffer->conversion_shift[j]] - = buffer->resource.allocatedMemory[buffer->stride * i + j]; + /* Done already */ + j += 3; break; - - case CONV_FLOAT16_2: - { - float *out = (float *)(&data[buffer->conversion_stride * i + j + buffer->conversion_shift[j]]); - const WORD *in = (WORD *)(&buffer->resource.allocatedMemory[i * buffer->stride + j]); - - out[1] = float_16_to_32(in + 1); - out[0] = float_16_to_32(in + 0); - j += 3; /* Skip 3 additional bytes,as a FLOAT16_2 has 4 bytes */ + case CONV_D3DCOLOR: + fixup_d3dcolor((DWORD *) (data + i * buffer->stride + j)); + j += 3; break; - } - default: - FIXME("Unimplemented conversion %#x in shifted conversion.\n", buffer->conversion_map[j]); + case CONV_POSITIONT: + fixup_transformed_pos((float *) (data + i * buffer->stride + j)); + j += 15; break; + default: + FIXME("Unimplemented conversion %d in shifted conversion\n", buffer->conversion_map[j]); } } } @@ -1103,58 +951,10 @@ void CDECL wined3d_buffer_preload(struct wined3d_buffer *buffer) ENTER_GL(); GL_EXTCALL(glBindBufferARB(buffer->buffer_type_hint, buffer->buffer_object)); checkGLcall("glBindBufferARB"); - GL_EXTCALL(glBufferSubDataARB(buffer->buffer_type_hint, 0, vertices * buffer->conversion_stride, data)); + GL_EXTCALL(glBufferSubDataARB(buffer->buffer_type_hint, start, len, data + start)); checkGLcall("glBufferSubDataARB"); LEAVE_GL(); } - else - { - data = HeapAlloc(GetProcessHeap(), 0, buffer->resource.size); - - while (buffer->modified_areas) - { - buffer->modified_areas--; - start = buffer->maps[buffer->modified_areas].offset; - len = buffer->maps[buffer->modified_areas].size; - end = start + len; - - memcpy(data + start, buffer->resource.allocatedMemory + start, end - start); - for (i = start / buffer->stride; i < min((end / buffer->stride) + 1, vertices); ++i) - { - for (j = 0; j < buffer->stride; ++j) - { - switch (buffer->conversion_map[j]) - { - case CONV_NONE: - /* Done already */ - j += 3; - break; - case CONV_D3DCOLOR: - fixup_d3dcolor((DWORD *)(data + i * buffer->stride + j)); - j += 3; - break; - - case CONV_POSITIONT: - fixup_transformed_pos((float *)(data + i * buffer->stride + j)); - j += 15; - break; - - case CONV_FLOAT16_2: - ERR("Did not expect FLOAT16 conversion in unshifted conversion.\n"); - default: - FIXME("Unimplemented conversion %u in unshifted conversion.\n", buffer->conversion_map[j]); - } - } - } - - ENTER_GL(); - GL_EXTCALL(glBindBufferARB(buffer->buffer_type_hint, buffer->buffer_object)); - checkGLcall("glBindBufferARB"); - GL_EXTCALL(glBufferSubDataARB(buffer->buffer_type_hint, start, len, data + start)); - checkGLcall("glBufferSubDataARB"); - LEAVE_GL(); - } - } HeapFree(GetProcessHeap(), 0, data); diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c index 6ef28c71b2f9d1712d77676d6dbf58f81a2d9814..9d54076cb27d3d46caf5312b6a1857c687be0f48 100644 --- a/dlls/wined3d/state.c +++ b/dlls/wined3d/state.c @@ -4132,7 +4132,6 @@ static void loadNumberedArrays(struct wined3d_stateblock *stateblock, GLuint curVBO = gl_info->supported[ARB_VERTEX_BUFFER_OBJECT] ? ~0U : 0; int i; struct wined3d_buffer *vb; - DWORD_PTR shift_index; /* Default to no instancing */ stateblock->device->instancedDraw = FALSE; @@ -4172,31 +4171,12 @@ static void loadNumberedArrays(struct wined3d_stateblock *stateblock, * curVBO will be 0. If there is a vertex buffer but no vbo we * won't be load converted attributes anyway. */ vb = stream->buffer; - if (curVBO && vb->conversion_shift) - { - TRACE("Loading attribute from shifted buffer\n"); - TRACE("Attrib %d has original stride %d, new stride %d\n", - i, stream_info->elements[i].stride, vb->conversion_stride); - TRACE("Original offset %p, additional offset 0x%08x\n", - stream_info->elements[i].data, vb->conversion_shift[(DWORD_PTR)stream_info->elements[i].data]); - TRACE("Opengl type %#x\n", stream_info->elements[i].format->gl_vtx_type); - shift_index = ((DWORD_PTR)stream_info->elements[i].data + stream->offset); - shift_index = shift_index % stream_info->elements[i].stride; - GL_EXTCALL(glVertexAttribPointerARB(i, stream_info->elements[i].format->gl_vtx_format, - stream_info->elements[i].format->gl_vtx_type, - stream_info->elements[i].format->gl_normalized, - vb->conversion_stride, stream_info->elements[i].data + vb->conversion_shift[shift_index] - + stateblock->state.load_base_vertex_index * stream_info->elements[i].stride - + stream->offset)); - - } else { - GL_EXTCALL(glVertexAttribPointerARB(i, stream_info->elements[i].format->gl_vtx_format, - stream_info->elements[i].format->gl_vtx_type, - stream_info->elements[i].format->gl_normalized, - stream_info->elements[i].stride, stream_info->elements[i].data - + stateblock->state.load_base_vertex_index * stream_info->elements[i].stride - + stream->offset)); - } + GL_EXTCALL(glVertexAttribPointerARB(i, stream_info->elements[i].format->gl_vtx_format, + stream_info->elements[i].format->gl_vtx_type, + stream_info->elements[i].format->gl_normalized, + stream_info->elements[i].stride, stream_info->elements[i].data + + stateblock->state.load_base_vertex_index * stream_info->elements[i].stride + + stream->offset)); if (!(context->numbered_array_mask & (1 << i))) { diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 4ef1cb672e918ec8bc1b6e130478b30670edbc4a..79b7f57fd44d16a513ac9d17553dff138210a42b 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2451,7 +2451,6 @@ enum wined3d_buffer_conversion_type CONV_NONE, CONV_D3DCOLOR, CONV_POSITIONT, - CONV_FLOAT16_2, /* Also handles FLOAT16_4 */ }; struct wined3d_map_range @@ -2493,8 +2492,6 @@ struct wined3d_buffer UINT stride; /* 0 if no conversion */ UINT conversion_stride; /* 0 if no shifted conversion */ enum wined3d_buffer_conversion_type *conversion_map; /* NULL if no conversion */ - /* Extra load offsets, for FLOAT16 conversion */ - UINT *conversion_shift; /* NULL if no shifted conversion */ }; static inline struct wined3d_buffer *buffer_from_resource(struct wined3d_resource *resource)