wined3d: Add stream offsets in device_stream_info_from_declaration().

They're not going to change until the next time the stream info is updated.
This would of course mainly be useful if we managed to do more than one or two
draws with the same stream info.

dlls/wined3d/buffer.c

@@ -228,7 +228,6 @@ static BOOL buffer_process_converted_attribute(struct wined3d_buffer *This,
         const enum wined3d_buffer_conversion_type conversion_type,
         const struct wined3d_stream_info_element *attrib, DWORD *stride_this_run)
 {
-    DWORD offset = This->resource.device->stateBlock->state.streams[attrib->stream_idx].offset;
     DWORD attrib_size;
     BOOL ret = FALSE;
     unsigned int i;
@@ -265,7 +264,7 @@ static BOOL buffer_process_converted_attribute(struct wined3d_buffer *This,
         }
     }
 
-    data = (((DWORD_PTR)attrib->data.addr) + offset) % This->stride;
+    data = ((DWORD_PTR)attrib->data.addr) % This->stride;
     attrib_size = attrib->format->component_count * attrib->format->component_size;
     for (i = 0; i < attrib_size; ++i)
     {

dlls/wined3d/device.c

@@ -189,7 +189,8 @@ void device_stream_info_from_declaration(struct wined3d_device *device,
     for (i = 0; i < declaration->element_count; ++i)
     {
         const struct wined3d_vertex_declaration_element *element = &declaration->elements[i];
-        struct wined3d_buffer *buffer = device->stateBlock->state.streams[element->input_slot].buffer;
+        const struct wined3d_stream_state *stream = &device->stateBlock->state.streams[element->input_slot];
+        struct wined3d_buffer *buffer = stream->buffer;
         struct wined3d_bo_address data;
         BOOL stride_used;
         unsigned int idx;
@@ -203,7 +204,7 @@ void device_stream_info_from_declaration(struct wined3d_device *device,
         data.buffer_object = 0;
         data.addr = NULL;
 
-        stride = device->stateBlock->state.streams[element->input_slot].stride;
+        stride = stream->stride;
         if (device->stateBlock->state.user_stream)
         {
             TRACE("Stream %u is UP, %p\n", element->input_slot, buffer);
@@ -292,6 +293,8 @@ void device_stream_info_from_declaration(struct wined3d_device *device,
                     debug_d3ddeclusage(element->usage), element->usage_idx, element->input_slot,
                     element->offset, stride, debug_d3dformat(element->format->id), data.buffer_object);
 
+            data.addr += stream->offset;
+
             stream_info->elements[idx].format = element->format;
             stream_info->elements[idx].data = data;
             stream_info->elements[idx].stride = stride;

dlls/wined3d/drawprim.c

@@ -74,7 +74,6 @@ static void drawStridedSlow(struct wined3d_device *device, const struct wined3d_
     const DWORD               *pIdxBufL     = NULL;
     UINT vx_index;
     const struct wined3d_state *state = &device->stateBlock->state;
-    const struct wined3d_stream_state *streams = state->streams;
     LONG SkipnStrides = startIdx;
     BOOL pixelShader = use_ps(state);
     BOOL specular_fog = FALSE;
@@ -111,13 +110,13 @@ static void drawStridedSlow(struct wined3d_device *device, const struct wined3d_
     if (si->use_map & (1 << WINED3D_FFP_POSITION))
     {
         element = &si->elements[WINED3D_FFP_POSITION];
-        position = element->data.addr + streams[element->stream_idx].offset;
+        position = element->data.addr;
     }
 
     if (si->use_map & (1 << WINED3D_FFP_NORMAL))
     {
         element = &si->elements[WINED3D_FFP_NORMAL];
-        normal = element->data.addr + streams[element->stream_idx].offset;
+        normal = element->data.addr;
     }
     else
     {
@@ -128,7 +127,7 @@ static void drawStridedSlow(struct wined3d_device *device, const struct wined3d_
     if (si->use_map & (1 << WINED3D_FFP_DIFFUSE))
     {
         element = &si->elements[WINED3D_FFP_DIFFUSE];
-        diffuse = element->data.addr + streams[element->stream_idx].offset;
+        diffuse = element->data.addr;
 
         if (num_untracked_materials && element->format->id != WINED3DFMT_B8G8R8A8_UNORM)
             FIXME("Implement diffuse color tracking from %s\n", debug_d3dformat(element->format->id));
@@ -141,7 +140,7 @@ static void drawStridedSlow(struct wined3d_device *device, const struct wined3d_
     if (si->use_map & (1 << WINED3D_FFP_SPECULAR))
     {
         element = &si->elements[WINED3D_FFP_SPECULAR];
-        specular = element->data.addr + streams[element->stream_idx].offset;
+        specular = element->data.addr;
 
         /* special case where the fog density is stored in the specular alpha channel */
         if (state->render_states[WINED3DRS_FOGENABLE]
@@ -201,7 +200,7 @@ static void drawStridedSlow(struct wined3d_device *device, const struct wined3d_
         if (si->use_map & (1 << (WINED3D_FFP_TEXCOORD0 + coordIdx)))
         {
             element = &si->elements[WINED3D_FFP_TEXCOORD0 + coordIdx];
-            texCoords[coordIdx] = element->data.addr + streams[element->stream_idx].offset;
+            texCoords[coordIdx] = element->data.addr;
             tex_mask |= (1 << textureNo);
         }
         else
@@ -465,8 +464,7 @@ static void drawStridedSlowVs(const struct wined3d_gl_info *gl_info, const struc
         {
             if (!(si->use_map & (1 << i))) continue;
 
-            ptr = si->elements[i].data.addr + si->elements[i].stride * SkipnStrides
+            ptr = si->elements[i].data.addr + si->elements[i].stride * SkipnStrides;
-                    + state->streams[si->elements[i].stream_idx].offset;
 
             send_attribute(gl_info, si->elements[i].format->id, i, ptr);
         }
@@ -530,8 +528,7 @@ static void drawStridedInstanced(const struct wined3d_gl_info *gl_info, const st
         /* Specify the instanced attributes using immediate mode calls */
         for(j = 0; j < numInstancedAttribs; j++) {
             const BYTE *ptr = si->elements[instancedData[j]].data.addr
-                    + si->elements[instancedData[j]].stride * i
+                    + si->elements[instancedData[j]].stride * i;
-                    + state->streams[si->elements[instancedData[j]].stream_idx].offset;
             if (si->elements[instancedData[j]].data.buffer_object)
             {
                 struct wined3d_buffer *vb = state->streams[si->elements[instancedData[j]].stream_idx].buffer;

dlls/wined3d/state.c

@@ -3270,7 +3270,6 @@ static void load_tex_coords(const struct wined3d_context *context, const struct
         if (coordIdx < MAX_TEXTURES && (si->use_map & (1 << (WINED3D_FFP_TEXCOORD0 + coordIdx))))
         {
             const struct wined3d_stream_info_element *e = &si->elements[WINED3D_FFP_TEXCOORD0 + coordIdx];
-            const struct wined3d_stream_state *stream = &state->streams[e->stream_idx];
 
             TRACE("Setting up texture %u, idx %d, coordindx %u, data {%#x:%p}.\n",
                     textureNo, mapped_stage, coordIdx, e->data.buffer_object, e->data.addr);
@@ -3287,7 +3286,7 @@ static void load_tex_coords(const struct wined3d_context *context, const struct
 
             /* The coords to supply depend completely on the fvf / vertex shader */
             glTexCoordPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
-                    e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                    e->data.addr + state->load_base_vertex_index * e->stride);
             glEnableClientState(GL_TEXTURE_COORD_ARRAY);
         }
         else
@@ -4046,7 +4045,6 @@ static void load_numbered_arrays(struct wined3d_context *context,
     const struct wined3d_gl_info *gl_info = context->gl_info;
     GLuint curVBO = gl_info->supported[ARB_VERTEX_BUFFER_OBJECT] ? ~0U : 0;
     int i;
-    struct wined3d_buffer *vb;
 
     /* Default to no instancing */
     device->instancedDraw = FALSE;
@@ -4085,13 +4083,11 @@ static void load_numbered_arrays(struct wined3d_context *context,
              * pointer. vb can point to a user pointer data blob. In that case
              * curVBO will be 0. If there is a vertex buffer but no vbo we
              * won't be load converted attributes anyway. */
-            vb = stream->buffer;
             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.addr
-                    + state->load_base_vertex_index * stream_info->elements[i].stride
+                    + state->load_base_vertex_index * stream_info->elements[i].stride));
-                    + stream->offset));
 
             if (!(context->numbered_array_mask & (1 << i)))
             {
@@ -4105,11 +4101,10 @@ static void load_numbered_arrays(struct wined3d_context *context,
              * glVertexAttribPointerARB doesn't do that. Instead disable the
              * pointer and set up the attribute statically. But we have to
              * figure out the system memory address. */
-            const BYTE *ptr = stream_info->elements[i].data.addr + stream->offset;
+            const BYTE *ptr = stream_info->elements[i].data.addr;
             if (stream_info->elements[i].data.buffer_object)
             {
-                vb = stream->buffer;
+                ptr += (ULONG_PTR)buffer_get_sysmem(stream->buffer, gl_info);
-                ptr += (ULONG_PTR)buffer_get_sysmem(vb, gl_info);
             }
 
             if (context->numbered_array_mask & (1 << i)) unload_numbered_array(context, i);
@@ -4209,7 +4204,6 @@ static void load_vertex_data(const struct wined3d_context *context,
     const struct wined3d_gl_info *gl_info = context->gl_info;
     GLuint curVBO = gl_info->supported[ARB_VERTEX_BUFFER_OBJECT] ? ~0U : 0;
     const struct wined3d_stream_info_element *e;
-    const struct wined3d_stream_state *stream;
 
     TRACE("Using fast vertex array code\n");
 
@@ -4221,12 +4215,11 @@ static void load_vertex_data(const struct wined3d_context *context,
             || si->use_map & (1 << WINED3D_FFP_BLENDINDICES))
     {
         e = &si->elements[WINED3D_FFP_BLENDWEIGHT];
-        stream = &state->streams[e->stream_idx];
 
         if (gl_info->supported[ARB_VERTEX_BLEND])
         {
             TRACE("Blend %u %p %u\n", e->format->component_count,
-                    e->data.addr + state->load_base_vertex_index * e->stride, e->stride + stream->offset);
+                    e->data.addr + state->load_base_vertex_index * e->stride, e->stride);
 
             glEnableClientState(GL_WEIGHT_ARRAY_ARB);
             checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
@@ -4244,9 +4237,9 @@ static void load_vertex_data(const struct wined3d_context *context,
                     e->format->gl_vtx_format,
                     e->format->gl_vtx_type,
                     e->stride,
-                    e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                    e->data.addr + state->load_base_vertex_index * e->stride);
             GL_EXTCALL(glWeightPointerARB(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
-                    e->data.addr + state->load_base_vertex_index * e->stride + stream->offset));
+                    e->data.addr + state->load_base_vertex_index * e->stride));
 
             checkGLcall("glWeightPointerARB");
 
@@ -4288,7 +4281,6 @@ static void load_vertex_data(const struct wined3d_context *context,
     if (si->use_map & (1 << WINED3D_FFP_POSITION))
     {
         e = &si->elements[WINED3D_FFP_POSITION];
-        stream = &state->streams[e->stream_idx];
 
         if (curVBO != e->data.buffer_object)
         {
@@ -4308,17 +4300,17 @@ static void load_vertex_data(const struct wined3d_context *context,
         if (!e->data.buffer_object)
         {
             TRACE("glVertexPointer(3, %#x, %#x, %p);\n", e->format->gl_vtx_type, e->stride,
-                    e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                    e->data.addr + state->load_base_vertex_index * e->stride);
             glVertexPointer(3 /* min(e->format->gl_vtx_format, 3) */, e->format->gl_vtx_type, e->stride,
-                    e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                    e->data.addr + state->load_base_vertex_index * e->stride);
         }
         else
         {
             TRACE("glVertexPointer(%#x, %#x, %#x, %p);\n",
                     e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
-                    e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                    e->data.addr + state->load_base_vertex_index * e->stride);
             glVertexPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
-                    e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                    e->data.addr + state->load_base_vertex_index * e->stride);
         }
         checkGLcall("glVertexPointer(...)");
         glEnableClientState(GL_VERTEX_ARRAY);
@@ -4329,7 +4321,6 @@ static void load_vertex_data(const struct wined3d_context *context,
     if (si->use_map & (1 << WINED3D_FFP_NORMAL))
     {
         e = &si->elements[WINED3D_FFP_NORMAL];
-        stream = &state->streams[e->stream_idx];
 
         if (curVBO != e->data.buffer_object)
         {
@@ -4339,9 +4330,9 @@ static void load_vertex_data(const struct wined3d_context *context,
         }
 
         TRACE("glNormalPointer(%#x, %#x, %p);\n", e->format->gl_vtx_type, e->stride,
-                e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                e->data.addr + state->load_base_vertex_index * e->stride);
         glNormalPointer(e->format->gl_vtx_type, e->stride,
-                e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                e->data.addr + state->load_base_vertex_index * e->stride);
         checkGLcall("glNormalPointer(...)");
         glEnableClientState(GL_NORMAL_ARRAY);
         checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
@@ -4363,7 +4354,6 @@ static void load_vertex_data(const struct wined3d_context *context,
     if (si->use_map & (1 << WINED3D_FFP_DIFFUSE))
     {
         e = &si->elements[WINED3D_FFP_DIFFUSE];
-        stream = &state->streams[e->stream_idx];
 
         if (curVBO != e->data.buffer_object)
         {
@@ -4374,9 +4364,9 @@ static void load_vertex_data(const struct wined3d_context *context,
 
         TRACE("glColorPointer(%#x, %#x %#x, %p);\n",
                 e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
-                e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                e->data.addr + state->load_base_vertex_index * e->stride);
         glColorPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
-                e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                e->data.addr + state->load_base_vertex_index * e->stride);
         checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
         glEnableClientState(GL_COLOR_ARRAY);
         checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
@@ -4392,7 +4382,6 @@ static void load_vertex_data(const struct wined3d_context *context,
         TRACE("setting specular colour\n");
 
         e = &si->elements[WINED3D_FFP_SPECULAR];
-        stream = &state->streams[e->stream_idx];
 
         if (gl_info->supported[EXT_SECONDARY_COLOR])
         {
@@ -4414,9 +4403,9 @@ static void load_vertex_data(const struct wined3d_context *context,
                  * 4 component secondary colors use it
                  */
                 TRACE("glSecondaryColorPointer(%#x, %#x, %#x, %p);\n", format, type, e->stride,
-                        e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                        e->data.addr + state->load_base_vertex_index * e->stride);
                 GL_EXTCALL(glSecondaryColorPointerEXT(format, type, e->stride,
-                        e->data.addr + state->load_base_vertex_index * e->stride + stream->offset));
+                        e->data.addr + state->load_base_vertex_index * e->stride));
                 checkGLcall("glSecondaryColorPointerEXT(format, type, ...)");
             }
             else
@@ -4425,9 +4414,9 @@ static void load_vertex_data(const struct wined3d_context *context,
                 {
                     case GL_UNSIGNED_BYTE:
                         TRACE("glSecondaryColorPointer(3, GL_UNSIGNED_BYTE, %#x, %p);\n", e->stride,
-                                e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                                e->data.addr + state->load_base_vertex_index * e->stride);
                         GL_EXTCALL(glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE, e->stride,
-                                e->data.addr + state->load_base_vertex_index * e->stride + stream->offset));
+                                e->data.addr + state->load_base_vertex_index * e->stride));
                         checkGLcall("glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE, ...)");
                         break;
 
@@ -4435,9 +4424,9 @@ static void load_vertex_data(const struct wined3d_context *context,
                         FIXME("Add 4 component specular color pointers for type %x\n", type);
                         /* Make sure that the right color component is dropped */
                         TRACE("glSecondaryColorPointer(3, %#x, %#x, %p);\n", type, e->stride,
-                                e->data.addr + state->load_base_vertex_index * e->stride + stream->offset);
+                                e->data.addr + state->load_base_vertex_index * e->stride);
                         GL_EXTCALL(glSecondaryColorPointerEXT(3, type, e->stride,
-                                e->data.addr + state->load_base_vertex_index * e->stride + stream->offset));
+                                e->data.addr + state->load_base_vertex_index * e->stride));
                         checkGLcall("glSecondaryColorPointerEXT(3, type, ...)");
                 }
             }