dlls/wined3d/drawprim.c

   1 /*
   2  * WINED3D draw functions
   3  *
   4  * Copyright 2002-2004 Jason Edmeades
   5  * Copyright 2002-2004 Raphael Junqueira
   6  * Copyright 2004 Christian Costa
   7  * Copyright 2005 Oliver Stieber
   8  * Copyright 2006, 2008 Henri Verbeet
   9  * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
  10  * Copyright 2009 Henri Verbeet for CodeWeavers
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  25  */
  26
  27 #include "config.h"
  28 #include "wine/port.h"
  29
  30 #include "wined3d_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(d3d_draw);
  33 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);
  34 WINE_DECLARE_DEBUG_CHANNEL(d3d);
  35
  36 #include <stdio.h>
  37 #include <math.h>
  38
  39 /* Context activation is done by the caller. */
  40 static void draw_primitive_arrays(struct wined3d_context *context, const struct wined3d_state *state,
  41         const void *idx_data, unsigned int idx_size, int base_vertex_idx, unsigned int start_idx,
  42         unsigned int count, unsigned int start_instance, unsigned int instance_count)
  43 {
  44     const struct wined3d_ffp_attrib_ops *ops = &context->d3d_info->ffp_attrib_ops;
  45     GLenum idx_type = idx_size == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
  46     const struct wined3d_stream_info *si = &context->stream_info;
  47     unsigned int instanced_elements[ARRAY_SIZE(si->elements)];
  48     const struct wined3d_gl_info *gl_info = context->gl_info;
  49     unsigned int instanced_element_count = 0;
  50     unsigned int i, j;
  51
  52     if (!instance_count)
  53     {
  54         if (!idx_size)
  55         {
  56             gl_info->gl_ops.gl.p_glDrawArrays(state->gl_primitive_type, start_idx, count);
  57             checkGLcall("glDrawArrays");
  58             return;
  59         }
  60
  61         if (gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX])
  62         {
  63             GL_EXTCALL(glDrawElementsBaseVertex(state->gl_primitive_type, count, idx_type,
  64                     (const char *)idx_data + (idx_size * start_idx), base_vertex_idx));
  65             checkGLcall("glDrawElementsBaseVertex");
  66             return;
  67         }
  68
  69         gl_info->gl_ops.gl.p_glDrawElements(state->gl_primitive_type, count,
  70                 idx_type, (const char *)idx_data + (idx_size * start_idx));
  71         checkGLcall("glDrawElements");
  72         return;
  73     }
  74
  75     if (start_instance)
  76         FIXME("Start instance (%u) not supported.\n", start_instance);
  77
  78     if (gl_info->supported[ARB_INSTANCED_ARRAYS])
  79     {
  80         if (!idx_size)
  81         {
  82             GL_EXTCALL(glDrawArraysInstanced(state->gl_primitive_type, start_idx, count, instance_count));
  83             checkGLcall("glDrawArraysInstanced");
  84             return;
  85         }
  86
  87         if (gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX])
  88         {
  89             GL_EXTCALL(glDrawElementsInstancedBaseVertex(state->gl_primitive_type, count, idx_type,
  90                         (const char *)idx_data + (idx_size * start_idx), instance_count, base_vertex_idx));
  91             checkGLcall("glDrawElementsInstancedBaseVertex");
  92             return;
  93         }
  94
  95         GL_EXTCALL(glDrawElementsInstanced(state->gl_primitive_type, count, idx_type,
  96                     (const char *)idx_data + (idx_size * start_idx), instance_count));
  97         checkGLcall("glDrawElementsInstanced");
  98         return;
  99     }
 100
 101     /* Instancing emulation by mixing immediate mode and arrays. */
 102
 103     /* This is a nasty thing. MSDN says no hardware supports this and
 104      * applications have to use software vertex processing. We don't support
 105      * this for now.
 106      *
 107      * Shouldn't be too hard to support with OpenGL, in theory just call
 108      * glDrawArrays() instead of drawElements(). But the stream fequency value
 109      * has a different meaning in that situation. */
 110     if (!idx_size)
 111     {
 112         FIXME("Non-indexed instanced drawing is not supported\n");
 113         return;
 114     }
 115
 116     for (i = 0; i < ARRAY_SIZE(si->elements); ++i)
 117     {
 118         if (!(si->use_map & (1u << i)))
 119             continue;
 120
 121         if (state->streams[si->elements[i].stream_idx].flags & WINED3DSTREAMSOURCE_INSTANCEDATA)
 122             instanced_elements[instanced_element_count++] = i;
 123     }
 124
 125     for (i = 0; i < instance_count; ++i)
 126     {
 127         /* Specify the instanced attributes using immediate mode calls. */
 128         for (j = 0; j < instanced_element_count; ++j)
 129         {
 130             const struct wined3d_stream_info_element *element;
 131             unsigned int element_idx;
 132             const BYTE *ptr;
 133
 134             element_idx = instanced_elements[j];
 135             element = &si->elements[element_idx];
 136             ptr = element->data.addr + element->stride * i;
 137             if (element->data.buffer_object)
 138                 ptr += (ULONG_PTR)buffer_get_sysmem(state->streams[element->stream_idx].buffer, context);
 139             ops->generic[element->format->emit_idx](element_idx, ptr);
 140         }
 141
 142         if (gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX])
 143         {
 144             GL_EXTCALL(glDrawElementsBaseVertex(state->gl_primitive_type, count, idx_type,
 145                         (const char *)idx_data + (idx_size * start_idx), base_vertex_idx));
 146             checkGLcall("glDrawElementsBaseVertex");
 147         }
 148         else
 149         {
 150             gl_info->gl_ops.gl.p_glDrawElements(state->gl_primitive_type, count, idx_type,
 151                         (const char *)idx_data + (idx_size * start_idx));
 152             checkGLcall("glDrawElements");
 153         }
 154     }
 155 }
 156
 157 static unsigned int get_stride_idx(const void *idx_data, unsigned int idx_size,
 158         unsigned int base_vertex_idx, unsigned int start_idx, unsigned int vertex_idx)
 159 {
 160     if (!idx_data)
 161         return start_idx + vertex_idx;
 162     if (idx_size == 2)
 163         return ((const WORD *)idx_data)[start_idx + vertex_idx] + base_vertex_idx;
 164     return ((const DWORD *)idx_data)[start_idx + vertex_idx] + base_vertex_idx;
 165 }
 166
 167 /* Context activation is done by the caller. */
 168 static void draw_primitive_immediate_mode(struct wined3d_context *context, const struct wined3d_state *state,
 169         const struct wined3d_stream_info *si, const void *idx_data, unsigned int idx_size,
 170         int base_vertex_idx, unsigned int start_idx, unsigned int vertex_count, unsigned int instance_count)
 171 {
 172     const BYTE *position = NULL, *normal = NULL, *diffuse = NULL, *specular = NULL;
 173     const struct wined3d_d3d_info *d3d_info = context->d3d_info;
 174     unsigned int coord_idx, stride_idx, texture_idx, vertex_idx;
 175     const struct wined3d_gl_info *gl_info = context->gl_info;
 176     const struct wined3d_stream_info_element *element;
 177     const BYTE *tex_coords[WINED3DDP_MAXTEXCOORD];
 178     unsigned int texture_unit, texture_stages;
 179     const struct wined3d_ffp_attrib_ops *ops;
 180     unsigned int untracked_material_count;
 181     unsigned int tex_mask = 0;
 182     BOOL specular_fog = FALSE;
 183     BOOL ps = use_ps(state);
 184     const void *ptr;
 185
 186     static unsigned int once;
 187
 188     if (!once++)
 189         FIXME_(d3d_perf)("Drawing using immediate mode.\n");
 190     else
 191         WARN_(d3d_perf)("Drawing using immediate mode.\n");
 192
 193     if (!idx_size && idx_data)
 194         ERR("Non-NULL idx_data with 0 idx_size, this should never happen.\n");
 195
 196     if (instance_count)
 197         FIXME("Instancing not implemented.\n");
 198
 199     /* Immediate mode drawing can't make use of indices in a vbo - get the
 200      * data from the index buffer. If the index buffer has no vbo (not
 201      * supported or other reason), or with user pointer drawing idx_data
 202      * will be non-NULL. */
 203     if (idx_size && !idx_data)
 204         idx_data = buffer_get_sysmem(state->index_buffer, context);
 205
 206     ops = &d3d_info->ffp_attrib_ops;
 207
 208     gl_info->gl_ops.gl.p_glBegin(state->gl_primitive_type);
 209
 210     if (use_vs(state) || d3d_info->ffp_generic_attributes)
 211     {
 212         for (vertex_idx = 0; vertex_idx < vertex_count; ++vertex_idx)
 213         {
 214             unsigned int use_map = si->use_map;
 215             unsigned int element_idx;
 216
 217             stride_idx = get_stride_idx(idx_data, idx_size, base_vertex_idx, start_idx, vertex_idx);
 218             for (element_idx = MAX_ATTRIBS - 1; use_map; use_map &= ~(1u << element_idx), --element_idx)
 219             {
 220                 if (!(use_map & 1u << element_idx))
 221                     continue;
 222
 223                 ptr = si->elements[element_idx].data.addr + si->elements[element_idx].stride * stride_idx;
 224                 ops->generic[si->elements[element_idx].format->emit_idx](element_idx, ptr);
 225             }
 226         }
 227
 228         gl_info->gl_ops.gl.p_glEnd();
 229         return;
 230     }
 231
 232     if (si->use_map & (1u << WINED3D_FFP_POSITION))
 233         position = si->elements[WINED3D_FFP_POSITION].data.addr;
 234
 235     if (si->use_map & (1u << WINED3D_FFP_NORMAL))
 236         normal = si->elements[WINED3D_FFP_NORMAL].data.addr;
 237     else
 238         gl_info->gl_ops.gl.p_glNormal3f(0.0f, 0.0f, 0.0f);
 239
 240     untracked_material_count = context->num_untracked_materials;
 241     if (si->use_map & (1u << WINED3D_FFP_DIFFUSE))
 242     {
 243         element = &si->elements[WINED3D_FFP_DIFFUSE];
 244         diffuse = element->data.addr;
 245
 246         if (untracked_material_count && element->format->id != WINED3DFMT_B8G8R8A8_UNORM)
 247             FIXME("Implement diffuse color tracking from %s.\n", debug_d3dformat(element->format->id));
 248     }
 249     else
 250     {
 251         gl_info->gl_ops.gl.p_glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 252     }
 253
 254     if (si->use_map & (1u << WINED3D_FFP_SPECULAR))
 255     {
 256         element = &si->elements[WINED3D_FFP_SPECULAR];
 257         specular = element->data.addr;
 258
 259         /* Special case where the fog density is stored in the specular alpha channel. */
 260         if (state->render_states[WINED3D_RS_FOGENABLE]
 261                 && (state->render_states[WINED3D_RS_FOGVERTEXMODE] == WINED3D_FOG_NONE
 262                     || si->elements[WINED3D_FFP_POSITION].format->id == WINED3DFMT_R32G32B32A32_FLOAT)
 263                 && state->render_states[WINED3D_RS_FOGTABLEMODE] == WINED3D_FOG_NONE)
 264         {
 265             if (gl_info->supported[EXT_FOG_COORD])
 266             {
 267                 if (element->format->id == WINED3DFMT_B8G8R8A8_UNORM)
 268                     specular_fog = TRUE;
 269                 else
 270                     FIXME("Implement fog coordinates from %s.\n", debug_d3dformat(element->format->id));
 271             }
 272             else
 273             {
 274                 static unsigned int once;
 275
 276                 if (!once++)
 277                     FIXME("Implement fog for transformed vertices in software.\n");
 278             }
 279         }
 280     }
 281     else if (gl_info->supported[EXT_SECONDARY_COLOR])
 282     {
 283         GL_EXTCALL(glSecondaryColor3fEXT)(0.0f, 0.0f, 0.0f);
 284     }
 285
 286     texture_stages = d3d_info->limits.ffp_blend_stages;
 287     for (texture_idx = 0; texture_idx < texture_stages; ++texture_idx)
 288     {
 289         if (!gl_info->supported[ARB_MULTITEXTURE] && texture_idx > 0)
 290         {
 291             FIXME("Program using multiple concurrent textures which this OpenGL implementation doesn't support.\n");
 292             continue;
 293         }
 294
 295         if (!ps && !state->textures[texture_idx])
 296             continue;
 297
 298         texture_unit = context->tex_unit_map[texture_idx];
 299         if (texture_unit == WINED3D_UNMAPPED_STAGE)
 300             continue;
 301
 302         coord_idx = state->texture_states[texture_idx][WINED3D_TSS_TEXCOORD_INDEX];
 303         if (coord_idx > 7)
 304         {
 305             TRACE("Skipping generated coordinates (%#x) for texture %u.\n", coord_idx, texture_idx);
 306             continue;
 307         }
 308
 309         if (si->use_map & (1u << (WINED3D_FFP_TEXCOORD0 + coord_idx)))
 310         {
 311             tex_coords[coord_idx] = si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].data.addr;
 312             tex_mask |= (1u << texture_idx);
 313         }
 314         else
 315         {
 316             TRACE("Setting default coordinates for texture %u.\n", texture_idx);
 317             if (gl_info->supported[ARB_MULTITEXTURE])
 318                 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + texture_unit, 0.0f, 0.0f, 0.0f, 1.0f));
 319             else
 320                 gl_info->gl_ops.gl.p_glTexCoord4f(0.0f, 0.0f, 0.0f, 1.0f);
 321         }
 322     }
 323
 324     /* Blending data and point sizes are not supported by this function. They
 325      * are not supported by the fixed function pipeline at all. A FIXME for
 326      * them is printed after decoding the vertex declaration. */
 327     for (vertex_idx = 0; vertex_idx < vertex_count; ++vertex_idx)
 328     {
 329         unsigned int tmp_tex_mask;
 330
 331         stride_idx = get_stride_idx(idx_data, idx_size, base_vertex_idx, start_idx, vertex_idx);
 332
 333         if (normal)
 334         {
 335             ptr = normal + stride_idx * si->elements[WINED3D_FFP_NORMAL].stride;
 336             ops->normal[si->elements[WINED3D_FFP_NORMAL].format->emit_idx](ptr);
 337         }
 338
 339         if (diffuse)
 340         {
 341             ptr = diffuse + stride_idx * si->elements[WINED3D_FFP_DIFFUSE].stride;
 342             ops->diffuse[si->elements[WINED3D_FFP_DIFFUSE].format->emit_idx](ptr);
 343
 344             if (untracked_material_count)
 345             {
 346                 struct wined3d_color color;
 347                 unsigned int i;
 348
 349                 wined3d_color_from_d3dcolor(&color, *(const DWORD *)ptr);
 350                 for (i = 0; i < untracked_material_count; ++i)
 351                 {
 352                     gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, context->untracked_materials[i], &color.r);
 353                 }
 354             }
 355         }
 356
 357         if (specular)
 358         {
 359             ptr = specular + stride_idx * si->elements[WINED3D_FFP_SPECULAR].stride;
 360             ops->specular[si->elements[WINED3D_FFP_SPECULAR].format->emit_idx](ptr);
 361
 362             if (specular_fog)
 363                 GL_EXTCALL(glFogCoordfEXT((float)(*(const DWORD *)ptr >> 24)));
 364         }
 365
 366         tmp_tex_mask = tex_mask;
 367         for (texture_idx = 0; tmp_tex_mask; tmp_tex_mask >>= 1, ++texture_idx)
 368         {
 369             if (!(tmp_tex_mask & 1))
 370                 continue;
 371
 372             coord_idx = state->texture_states[texture_idx][WINED3D_TSS_TEXCOORD_INDEX];
 373             ptr = tex_coords[coord_idx] + (stride_idx * si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].stride);
 374             ops->texcoord[si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].format->emit_idx](
 375                     GL_TEXTURE0_ARB + context->tex_unit_map[texture_idx], ptr);
 376         }
 377
 378         if (position)
 379         {
 380             ptr = position + stride_idx * si->elements[WINED3D_FFP_POSITION].stride;
 381             ops->position[si->elements[WINED3D_FFP_POSITION].format->emit_idx](ptr);
 382         }
 383     }
 384
 385     gl_info->gl_ops.gl.p_glEnd();
 386     checkGLcall("glEnd and previous calls");
 387 }
 388
 389 static void remove_vbos(struct wined3d_context *context,
 390         const struct wined3d_state *state, struct wined3d_stream_info *s)
 391 {
 392     unsigned int i;
 393
 394     for (i = 0; i < (sizeof(s->elements) / sizeof(*s->elements)); ++i)
 395     {
 396         struct wined3d_stream_info_element *e;
 397
 398         if (!(s->use_map & (1u << i))) continue;
 399
 400         e = &s->elements[i];
 401         if (e->data.buffer_object)
 402         {
 403             struct wined3d_buffer *vb = state->streams[e->stream_idx].buffer;
 404             e->data.buffer_object = 0;
 405             e->data.addr = (BYTE *)((ULONG_PTR)e->data.addr + (ULONG_PTR)buffer_get_sysmem(vb, context));
 406         }
 407     }
 408 }
 409
 410 /* Routine common to the draw primitive and draw indexed primitive routines */
 411 void draw_primitive(struct wined3d_device *device, const struct wined3d_state *state,
 412         int base_vertex_idx, unsigned int start_idx, unsigned int index_count,
 413         unsigned int start_instance, unsigned int instance_count, BOOL indexed)
 414 {
 415     const struct wined3d_fb_state *fb = state->fb;
 416     const struct wined3d_stream_info *stream_info;
 417     struct wined3d_event_query *ib_query = NULL;
 418     struct wined3d_stream_info si_emulated;
 419     struct wined3d_rendertarget_view *dsv;
 420     const struct wined3d_gl_info *gl_info;
 421     struct wined3d_context *context;
 422     unsigned int i, idx_size = 0;
 423     const void *idx_data = NULL;
 424     BOOL emulation = FALSE;
 425
 426     if (!index_count)
 427         return;
 428
 429     context = context_acquire(device, wined3d_rendertarget_view_get_surface(fb->render_targets[0]));
 430     if (!context->valid)
 431     {
 432         context_release(context);
 433         WARN("Invalid context, skipping draw.\n");
 434         return;
 435     }
 436     gl_info = context->gl_info;
 437
 438     for (i = 0; i < gl_info->limits.buffers; ++i)
 439     {
 440         struct wined3d_rendertarget_view *rtv = fb->render_targets[i];
 441         struct wined3d_texture *rt;
 442
 443         if (!rtv || rtv->format->id == WINED3DFMT_NULL)
 444             continue;
 445
 446         rt = wined3d_texture_from_resource(rtv->resource);
 447         if (state->render_states[WINED3D_RS_COLORWRITEENABLE])
 448         {
 449             wined3d_texture_load_location(rt, rtv->sub_resource_idx, context, rtv->resource->draw_binding);
 450             wined3d_texture_invalidate_location(rt, rtv->sub_resource_idx, ~rtv->resource->draw_binding);
 451         }
 452         else
 453         {
 454             wined3d_texture_prepare_location(rt, rtv->sub_resource_idx, context, rtv->resource->draw_binding);
 455         }
 456     }
 457
 458     if ((dsv = fb->depth_stencil))
 459     {
 460         /* Note that this depends on the context_acquire() call above to set
 461          * context->render_offscreen properly. We don't currently take the
 462          * Z-compare function into account, but we could skip loading the
 463          * depthstencil for D3DCMP_NEVER and D3DCMP_ALWAYS as well. Also note
 464          * that we never copy the stencil data.*/
 465         DWORD location = context->render_offscreen ? dsv->resource->draw_binding : WINED3D_LOCATION_DRAWABLE;
 466         struct wined3d_surface *ds = wined3d_rendertarget_view_get_surface(dsv);
 467
 468         if (state->render_states[WINED3D_RS_ZWRITEENABLE] || state->render_states[WINED3D_RS_ZENABLE])
 469         {
 470             RECT current_rect, draw_rect, r;
 471
 472             if (!context->render_offscreen && ds != device->onscreen_depth_stencil)
 473                 device_switch_onscreen_ds(device, context, ds);
 474
 475             if (surface_get_sub_resource(ds)->locations & location)
 476                 SetRect(&current_rect, 0, 0, ds->ds_current_size.cx, ds->ds_current_size.cy);
 477             else
 478                 SetRectEmpty(&current_rect);
 479
 480             wined3d_get_draw_rect(state, &draw_rect);
 481
 482             IntersectRect(&r, &draw_rect, &current_rect);
 483             if (!EqualRect(&r, &draw_rect))
 484                 wined3d_texture_load_location(ds->container, dsv->sub_resource_idx, context, location);
 485             else
 486                 wined3d_texture_prepare_location(ds->container, dsv->sub_resource_idx, context, location);
 487         }
 488         else
 489             wined3d_texture_prepare_location(ds->container, dsv->sub_resource_idx, context, location);
 490     }
 491
 492     if (!context_apply_draw_state(context, device, state))
 493     {
 494         context_release(context);
 495         WARN("Unable to apply draw state, skipping draw.\n");
 496         return;
 497     }
 498
 499     if (fb->depth_stencil && state->render_states[WINED3D_RS_ZWRITEENABLE])
 500     {
 501         struct wined3d_surface *ds = wined3d_rendertarget_view_get_surface(fb->depth_stencil);
 502         DWORD location = context->render_offscreen ? ds->container->resource.draw_binding : WINED3D_LOCATION_DRAWABLE;
 503
 504         surface_modify_ds_location(ds, location, ds->ds_current_size.cx, ds->ds_current_size.cy);
 505     }
 506
 507     if ((!gl_info->supported[WINED3D_GL_VERSION_2_0]
 508             || !gl_info->supported[NV_POINT_SPRITE])
 509             && context->render_offscreen
 510             && state->render_states[WINED3D_RS_POINTSPRITEENABLE]
 511             && state->gl_primitive_type == GL_POINTS)
 512     {
 513         FIXME("Point sprite coordinate origin switching not supported.\n");
 514     }
 515
 516     stream_info = &context->stream_info;
 517     if (context->instance_count)
 518         instance_count = context->instance_count;
 519
 520     if (indexed)
 521     {
 522         struct wined3d_buffer *index_buffer = state->index_buffer;
 523         if (!index_buffer->buffer_object || !stream_info->all_vbo)
 524         {
 525             idx_data = index_buffer->resource.heap_memory;
 526         }
 527         else
 528         {
 529             ib_query = index_buffer->query;
 530             idx_data = NULL;
 531         }
 532         idx_data = (const BYTE *)idx_data + state->index_offset;
 533
 534         if (state->index_format == WINED3DFMT_R16_UINT)
 535             idx_size = 2;
 536         else
 537             idx_size = 4;
 538     }
 539
 540     if (!use_vs(state))
 541     {
 542         if (!stream_info->position_transformed && context->num_untracked_materials
 543                 && state->render_states[WINED3D_RS_LIGHTING])
 544         {
 545             static BOOL warned;
 546
 547             if (!warned++)
 548                 FIXME("Using software emulation because not all material properties could be tracked.\n");
 549             else
 550                 WARN_(d3d_perf)("Using software emulation because not all material properties could be tracked.\n");
 551             emulation = TRUE;
 552         }
 553         else if (context->fog_coord && state->render_states[WINED3D_RS_FOGENABLE])
 554         {
 555             static BOOL warned;
 556
 557             /* Either write a pipeline replacement shader or convert the
 558              * specular alpha from unsigned byte to a float in the vertex
 559              * buffer. */
 560             if (!warned++)
 561                 FIXME("Using software emulation because manual fog coordinates are provided.\n");
 562             else
 563                 WARN_(d3d_perf)("Using software emulation because manual fog coordinates are provided.\n");
 564             emulation = TRUE;
 565         }
 566
 567         if (emulation)
 568         {
 569             si_emulated = context->stream_info;
 570             remove_vbos(context, state, &si_emulated);
 571             stream_info = &si_emulated;
 572         }
 573     }
 574
 575     if (context->use_immediate_mode_draw || emulation)
 576         draw_primitive_immediate_mode(context, state, stream_info, idx_data,
 577                 idx_size, base_vertex_idx, start_idx, index_count, instance_count);
 578     else
 579         draw_primitive_arrays(context, state, idx_data, idx_size, base_vertex_idx,
 580                 start_idx, index_count, start_instance, instance_count);
 581
 582     if (ib_query)
 583         wined3d_event_query_issue(ib_query, device);
 584     for (i = 0; i < context->num_buffer_queries; ++i)
 585         wined3d_event_query_issue(context->buffer_queries[i], device);
 586
 587     if (wined3d_settings.strict_draw_ordering)
 588         gl_info->gl_ops.gl.p_glFlush(); /* Flush to ensure ordering across contexts. */
 589
 590     context_release(context);
 591
 592     TRACE("Done all gl drawing.\n");
 593 }