af062818b47340eef15700d2f0211576ba3506eevboxsync * WINED3D draw functions
af062818b47340eef15700d2f0211576ba3506eevboxsync * Copyright 2002-2004 Jason Edmeades
af062818b47340eef15700d2f0211576ba3506eevboxsync * Copyright 2002-2004 Raphael Junqueira
af062818b47340eef15700d2f0211576ba3506eevboxsync * Copyright 2004 Christian Costa
af062818b47340eef15700d2f0211576ba3506eevboxsync * Copyright 2005 Oliver Stieber
af062818b47340eef15700d2f0211576ba3506eevboxsync * Copyright 2006, 2008 Henri Verbeet
af062818b47340eef15700d2f0211576ba3506eevboxsync * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync * Copyright 2009 Henri Verbeet for CodeWeavers
af062818b47340eef15700d2f0211576ba3506eevboxsync * This library is free software; you can redistribute it and/or
af062818b47340eef15700d2f0211576ba3506eevboxsync * modify it under the terms of the GNU Lesser General Public
af062818b47340eef15700d2f0211576ba3506eevboxsync * License as published by the Free Software Foundation; either
af062818b47340eef15700d2f0211576ba3506eevboxsync * version 2.1 of the License, or (at your option) any later version.
af062818b47340eef15700d2f0211576ba3506eevboxsync * This library is distributed in the hope that it will be useful,
af062818b47340eef15700d2f0211576ba3506eevboxsync * but WITHOUT ANY WARRANTY; without even the implied warranty of
af062818b47340eef15700d2f0211576ba3506eevboxsync * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
af062818b47340eef15700d2f0211576ba3506eevboxsync * Lesser General Public License for more details.
af062818b47340eef15700d2f0211576ba3506eevboxsync * You should have received a copy of the GNU Lesser General Public
af062818b47340eef15700d2f0211576ba3506eevboxsync * License along with this library; if not, write to the Free Software
af062818b47340eef15700d2f0211576ba3506eevboxsync * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
4b9d6701570cb98fd36e209314239d104ec584d3vboxsync * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
4b9d6701570cb98fd36e209314239d104ec584d3vboxsync * other than GPL or LGPL is available it will apply instead, Oracle elects to use only
b955672b950093ff7416d1269dd4d3b69983bd8fvboxsync * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
b955672b950093ff7416d1269dd4d3b69983bd8fvboxsync * a choice of LGPL license versions is made available with the language indicating
b955672b950093ff7416d1269dd4d3b69983bd8fvboxsync * that LGPLv2 or any later version may be used, or where a choice of which version
b955672b950093ff7416d1269dd4d3b69983bd8fvboxsync * of the LGPL is applied is otherwise unspecified.
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsyncstatic void drawStridedFast(IWineD3DDevice *iface, GLenum primitive_type,
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync UINT count, UINT idx_size, const void *idx_data, UINT start_idx)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync TRACE("(%p) : glElements(%x, %d, ...)\n", iface, primitive_type, count);
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync idx_size == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT,
5112e32d7072e280613921c982a6672f2c859cf3vboxsync TRACE("(%p) : glDrawArrays(%#x, %d, %d)\n", iface, primitive_type, start_idx, count);
af062818b47340eef15700d2f0211576ba3506eevboxsync * Actually draw using the supplied information.
af062818b47340eef15700d2f0211576ba3506eevboxsync * Slower GL version which extracts info about each vertex in turn
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsyncstatic void drawStridedSlow(IWineD3DDevice *iface, const struct wined3d_context *context,
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync const struct wined3d_stream_info *si, UINT NumVertexes, GLenum glPrimType,
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
af062818b47340eef15700d2f0211576ba3506eevboxsync const UINT *streamOffset = This->stateBlock->streamOffset;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync long SkipnStrides = startIdx + This->stateBlock->loadBaseVertexIndex;
af062818b47340eef15700d2f0211576ba3506eevboxsync const BYTE *diffuse = NULL, *specular = NULL, *normal = NULL, *position = NULL;
5112e32d7072e280613921c982a6672f2c859cf3vboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
5112e32d7072e280613921c982a6672f2c859cf3vboxsync UINT texture_stages = gl_info->limits.texture_stages;
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Variable Initialization */
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Immediate mode drawing can't make use of indices in a vbo - get the data from the index buffer.
af062818b47340eef15700d2f0211576ba3506eevboxsync * If the index buffer has no vbo(not supported or other reason), or with user pointer drawing
af062818b47340eef15700d2f0211576ba3506eevboxsync * idxData will be != NULL
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync idxData = buffer_get_sysmem((struct wined3d_buffer *) This->stateBlock->pIndexData);
af062818b47340eef15700d2f0211576ba3506eevboxsync } else if (idxData) {
af062818b47340eef15700d2f0211576ba3506eevboxsync ERR("non-NULL idxData with 0 idxSize, this should never happen\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Start drawing in GL */
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync position = element->data + streamOffset[element->stream_idx];
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync normal = element->data + streamOffset[element->stream_idx];
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync num_untracked_materials = context->num_untracked_materials;
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync diffuse = element->data + streamOffset[element->stream_idx];
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync if (num_untracked_materials && element->format_desc->format != WINED3DFMT_B8G8R8A8_UNORM)
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync FIXME("Implement diffuse color tracking from %s\n", debug_d3dformat(element->format_desc->format));
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync specular = element->data + streamOffset[element->stream_idx];
af062818b47340eef15700d2f0211576ba3506eevboxsync /* special case where the fog density is stored in the specular alpha channel */
af062818b47340eef15700d2f0211576ba3506eevboxsync if (This->stateBlock->renderState[WINED3DRS_FOGENABLE]
af062818b47340eef15700d2f0211576ba3506eevboxsync && (This->stateBlock->renderState[WINED3DRS_FOGVERTEXMODE] == WINED3DFOG_NONE
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync || si->elements[WINED3D_FFP_POSITION].format_desc->format == WINED3DFMT_R32G32B32A32_FLOAT)
af062818b47340eef15700d2f0211576ba3506eevboxsync && This->stateBlock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE)
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync if (element->format_desc->format == WINED3DFMT_B8G8R8A8_UNORM) specular_fog = TRUE;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync else FIXME("Implement fog coordinates from %s\n", debug_d3dformat(element->format_desc->format));
af062818b47340eef15700d2f0211576ba3506eevboxsync /* TODO: Use the fog table code from old ddraw */
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("Implement fog for transformed vertices in software\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync for (textureNo = 0; textureNo < texture_stages; ++textureNo)
af062818b47340eef15700d2f0211576ba3506eevboxsync int coordIdx = This->stateBlock->textureState[textureNo][WINED3DTSS_TEXCOORDINDEX];
5112e32d7072e280613921c982a6672f2c859cf3vboxsync if (!gl_info->supported[ARB_MULTITEXTURE] && textureNo > 0)
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync if (!pixelShader && !This->stateBlock->textures[textureNo]) continue;
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync if (texture_idx == WINED3D_UNMAPPED_STAGE) continue;
af062818b47340eef15700d2f0211576ba3506eevboxsync TRACE("tex: %d - Skip tex coords, as being system generated\n", textureNo);
af062818b47340eef15700d2f0211576ba3506eevboxsync else if (coordIdx < 0)
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("tex: %d - Coord index %d is less than zero, expect a crash.\n", textureNo, coordIdx);
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync if (si->use_map & (1 << (WINED3D_FFP_TEXCOORD0 + coordIdx)))
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync element = &si->elements[WINED3D_FFP_TEXCOORD0 + coordIdx];
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync texCoords[coordIdx] = element->data + streamOffset[element->stream_idx];
af062818b47340eef15700d2f0211576ba3506eevboxsync TRACE("tex: %d - Skipping tex coords, as no data supplied\n", textureNo);
af062818b47340eef15700d2f0211576ba3506eevboxsync GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + texture_idx, 0, 0, 0, 1));
af062818b47340eef15700d2f0211576ba3506eevboxsync /* We shouldn't start this function if any VBO is involved. Should I put a safety check here?
af062818b47340eef15700d2f0211576ba3506eevboxsync * Guess it's not necessary(we crash then anyway) and would only eat CPU time
af062818b47340eef15700d2f0211576ba3506eevboxsync /* For each primitive */
af062818b47340eef15700d2f0211576ba3506eevboxsync for (vx_index = 0; vx_index < NumVertexes; ++vx_index) {
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Blending data and Point sizes are not supported by this function. They are not supported by the fixed
af062818b47340eef15700d2f0211576ba3506eevboxsync * function pipeline at all. A Fixme for them is printed after decoding the vertex declaration
af062818b47340eef15700d2f0211576ba3506eevboxsync /* For indexed data, we need to go a few more strides in */
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Indexed so work out the number of strides to skip */
af062818b47340eef15700d2f0211576ba3506eevboxsync SkipnStrides = pIdxBufS[startIdx + vx_index] + This->stateBlock->loadBaseVertexIndex;
af062818b47340eef15700d2f0211576ba3506eevboxsync SkipnStrides = pIdxBufL[startIdx + vx_index] + This->stateBlock->loadBaseVertexIndex;
af062818b47340eef15700d2f0211576ba3506eevboxsync for (texture = 0; tmp_tex_mask; tmp_tex_mask >>= 1, ++texture)
af062818b47340eef15700d2f0211576ba3506eevboxsync coord_idx = This->stateBlock->textureState[texture][WINED3DTSS_TEXCOORDINDEX];
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync ptr = texCoords[coord_idx] + (SkipnStrides * si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].stride);
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync multi_texcoord_funcs[si->elements[WINED3D_FFP_TEXCOORD0 + coord_idx].format_desc->emit_idx](
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Diffuse -------------------------------- */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync const void *ptrToCoords = diffuse + SkipnStrides * si->elements[WINED3D_FFP_DIFFUSE].stride;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync diffuse_funcs[si->elements[WINED3D_FFP_DIFFUSE].format_desc->emit_idx](ptrToCoords);
af062818b47340eef15700d2f0211576ba3506eevboxsync DWORD diffuseColor = ((const DWORD *)ptrToCoords)[0];
af062818b47340eef15700d2f0211576ba3506eevboxsync unsigned char i;
040b4a09341f574825386333398110f4db3e1e51vboxsync for (i = 0; i < num_untracked_materials; ++i)
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync glMaterialfv(GL_FRONT_AND_BACK, context->untracked_materials[i], color);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Specular ------------------------------- */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync const void *ptrToCoords = specular + SkipnStrides * si->elements[WINED3D_FFP_SPECULAR].stride;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync specular_funcs[si->elements[WINED3D_FFP_SPECULAR].format_desc->emit_idx](ptrToCoords);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Normal -------------------------------- */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync const void *ptrToCoords = normal + SkipnStrides * si->elements[WINED3D_FFP_NORMAL].stride;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync normal_funcs[si->elements[WINED3D_FFP_NORMAL].format_desc->emit_idx](ptrToCoords);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Position -------------------------------- */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync const void *ptrToCoords = position + SkipnStrides * si->elements[WINED3D_FFP_POSITION].stride;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync position_funcs[si->elements[WINED3D_FFP_POSITION].format_desc->emit_idx](ptrToCoords);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* For non indexed mode, step onto next parts */
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsyncstatic inline void send_attribute(IWineD3DDeviceImpl *This, WINED3DFORMAT format, const UINT index, const void *ptr)
5112e32d7072e280613921c982a6672f2c859cf3vboxsync const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync GL_EXTCALL(glVertexAttrib4NubvARB(index, (GLubyte *)&c));
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync /* else fallthrough */
af062818b47340eef15700d2f0211576ba3506eevboxsync GLshort s[4] = {((const GLshort *)ptr)[0], ((const GLshort *)ptr)[1], 0, 1};
af062818b47340eef15700d2f0211576ba3506eevboxsync GLushort s[4] = {((const GLushort *)ptr)[0], ((const GLushort *)ptr)[1], 0, 1};
af062818b47340eef15700d2f0211576ba3506eevboxsync /*glVertexAttrib3usvARB(instancedData[j], (GLushort *) ptr); Does not exist */
af062818b47340eef15700d2f0211576ba3506eevboxsync /*glVertexAttrib3NusvARB(instancedData[j], (GLushort *) ptr); Does not exist */
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Are those 16 bit floats. C doesn't have a 16 bit float type. I could read the single bits and calculate a 4
af062818b47340eef15700d2f0211576ba3506eevboxsync * byte float according to the IEEE standard
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync /* Not supported by GL_ARB_half_float_vertex */
af062818b47340eef15700d2f0211576ba3506eevboxsync float x = float_16_to_32(((const unsigned short *)ptr) + 0);
af062818b47340eef15700d2f0211576ba3506eevboxsync float y = float_16_to_32(((const unsigned short *)ptr) + 1);
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync /* Not supported by GL_ARB_half_float_vertex */
af062818b47340eef15700d2f0211576ba3506eevboxsync float x = float_16_to_32(((const unsigned short *)ptr) + 0);
af062818b47340eef15700d2f0211576ba3506eevboxsync float y = float_16_to_32(((const unsigned short *)ptr) + 1);
af062818b47340eef15700d2f0211576ba3506eevboxsync float z = float_16_to_32(((const unsigned short *)ptr) + 2);
af062818b47340eef15700d2f0211576ba3506eevboxsync float w = float_16_to_32(((const unsigned short *)ptr) + 3);
af062818b47340eef15700d2f0211576ba3506eevboxsync GL_EXTCALL(glVertexAttrib4fARB(index, x, y, z, w));
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync ERR("Unexpected attribute format: %s\n", debug_d3dformat(format));
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsyncstatic void drawStridedSlowVs(IWineD3DDevice *iface, const struct wined3d_stream_info *si, UINT numberOfVertices,
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync GLenum glPrimitiveType, const void *idxData, UINT idxSize, UINT startIdx)
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync long SkipnStrides = startIdx + This->stateBlock->loadBaseVertexIndex;
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DStateBlockImpl *stateblock = This->stateBlock;
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Immediate mode drawing can't make use of indices in a vbo - get the data from the index buffer.
af062818b47340eef15700d2f0211576ba3506eevboxsync * If the index buffer has no vbo(not supported or other reason), or with user pointer drawing
af062818b47340eef15700d2f0211576ba3506eevboxsync * idxData will be != NULL
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync idxData = buffer_get_sysmem((struct wined3d_buffer *) This->stateBlock->pIndexData);
af062818b47340eef15700d2f0211576ba3506eevboxsync } else if (idxData) {
af062818b47340eef15700d2f0211576ba3506eevboxsync ERR("non-NULL idxData with 0 idxSize, this should never happen\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Start drawing in GL */
af062818b47340eef15700d2f0211576ba3506eevboxsync for (vx_index = 0; vx_index < numberOfVertices; ++vx_index) {
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Indexed so work out the number of strides to skip */
af062818b47340eef15700d2f0211576ba3506eevboxsync SkipnStrides = pIdxBufS[startIdx + vx_index] + stateblock->loadBaseVertexIndex;
af062818b47340eef15700d2f0211576ba3506eevboxsync SkipnStrides = pIdxBufL[startIdx + vx_index] + stateblock->loadBaseVertexIndex;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync stateblock->streamOffset[si->elements[i].stream_idx];
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync send_attribute(This, si->elements[i].format_desc->format, i, ptr);
554f00fe75489f3f3ce7fbb6d126ce1d2c5c922cvboxsync/* GL locking is done by the caller */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsyncstatic inline void drawStridedInstanced(IWineD3DDevice *iface, const struct wined3d_stream_info *si,
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync UINT numberOfVertices, GLenum glPrimitiveType, const void *idxData, UINT idxSize,
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync UINT instancedData[sizeof(si->elements) / sizeof(*si->elements) /* 16 */];
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *) iface;
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DStateBlockImpl *stateblock = This->stateBlock;
af062818b47340eef15700d2f0211576ba3506eevboxsync /* This is a nasty thing. MSDN says no hardware supports that and apps have to use software vertex processing.
af062818b47340eef15700d2f0211576ba3506eevboxsync * We don't support this for now
af062818b47340eef15700d2f0211576ba3506eevboxsync * Shouldn't be too hard to support with opengl, in theory just call glDrawArrays instead of drawElements.
af062818b47340eef15700d2f0211576ba3506eevboxsync * But the StreamSourceFreq value has a different meaning in that situation.
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("Non-indexed instanced drawing is not supported\n");
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync TRACE("(%p) : glElements(%x, %d, ...)\n", This, glPrimitiveType, numberOfVertices);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* First, figure out how many instances we have to draw */
af062818b47340eef15700d2f0211576ba3506eevboxsync for(i = 0; i < MAX_STREAMS; i++) {
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Look at the streams and take the first one which matches */
af062818b47340eef15700d2f0211576ba3506eevboxsync if(((stateblock->streamFlags[i] & WINED3DSTREAMSOURCE_INSTANCEDATA) || (stateblock->streamFlags[i] & WINED3DSTREAMSOURCE_INDEXEDDATA)) && stateblock->streamSource[i]) {
af062818b47340eef15700d2f0211576ba3506eevboxsync /* D3D9 could set streamFreq 0 with (INSTANCEDATA or INDEXEDDATA) and then it is handled as 1. See d3d9/tests/visual.c-> stream_test() */
af062818b47340eef15700d2f0211576ba3506eevboxsync numInstances = stateblock->streamFreq[i]; /* use the specified number of instances from the first matched stream. See d3d9/tests/visual.c-> stream_test() */
af062818b47340eef15700d2f0211576ba3506eevboxsync break; /* break, because only the first suitable value is interesting */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync for (i = 0; i < sizeof(si->elements) / sizeof(*si->elements); ++i)
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync if (stateblock->streamFlags[si->elements[i].stream_idx] & WINED3DSTREAMSOURCE_INSTANCEDATA)
af062818b47340eef15700d2f0211576ba3506eevboxsync /* now draw numInstances instances :-) */
af062818b47340eef15700d2f0211576ba3506eevboxsync for(i = 0; i < numInstances; i++) {
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Specify the instanced attributes using immediate mode calls */
af062818b47340eef15700d2f0211576ba3506eevboxsync for(j = 0; j < numInstancedAttribs; j++) {
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync const BYTE *ptr = si->elements[instancedData[j]].data +
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync stateblock->streamOffset[si->elements[instancedData[j]].stream_idx];
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync (struct wined3d_buffer *)stateblock->streamSource[si->elements[instancedData[j]].stream_idx];
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync send_attribute(This, si->elements[instancedData[j]].format_desc->format, instancedData[j], ptr);
af062818b47340eef15700d2f0211576ba3506eevboxsync glDrawElements(glPrimitiveType, numberOfVertices, idxSize == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT,
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsyncstatic inline void remove_vbos(IWineD3DDeviceImpl *This, struct wined3d_stream_info *s)
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync unsigned int i;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync for (i = 0; i < (sizeof(s->elements) / sizeof(*s->elements)); ++i)
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync struct wined3d_buffer *vb = (struct wined3d_buffer *)This->stateBlock->streamSource[e->stream_idx];
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync e->data = (BYTE *)((unsigned long)e->data + (unsigned long)buffer_get_sysmem(vb));
af062818b47340eef15700d2f0211576ba3506eevboxsync/* Routine common to the draw primitive and draw indexed primitive routines */
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsyncvoid drawPrimitive(IWineD3DDevice *iface, UINT index_count, UINT StartIdx, UINT idxSize, const void *idxData)
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
af062818b47340eef15700d2f0211576ba3506eevboxsync unsigned int i;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync if (!index_count) return;
040b4a09341f574825386333398110f4db3e1e51vboxsync if (This->stateBlock->renderState[WINED3DRS_COLORWRITEENABLE])
040b4a09341f574825386333398110f4db3e1e51vboxsync /* Invalidate the back buffer memory so LockRect will read it the next time */
5112e32d7072e280613921c982a6672f2c859cf3vboxsync for (i = 0; i < This->adapter->gl_info.limits.buffers; ++i)
040b4a09341f574825386333398110f4db3e1e51vboxsync target = (IWineD3DSurfaceImpl *)This->render_targets[i];
040b4a09341f574825386333398110f4db3e1e51vboxsync IWineD3DSurface_LoadLocation((IWineD3DSurface *)target, SFLAG_INDRAWABLE, NULL);
040b4a09341f574825386333398110f4db3e1e51vboxsync IWineD3DSurface_ModifyLocation((IWineD3DSurface *)target, SFLAG_INDRAWABLE, TRUE);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Signals other modules that a drawing is in progress and the stateblock finalized */
5112e32d7072e280613921c982a6672f2c859cf3vboxsync context = context_acquire(This, This->render_targets[0], CTXUSAGE_DRAWPRIM);
5112e32d7072e280613921c982a6672f2c859cf3vboxsync /* Note that this depends on the context_acquire() call above to set
040b4a09341f574825386333398110f4db3e1e51vboxsync * This->render_offscreen properly. We don't currently take the
040b4a09341f574825386333398110f4db3e1e51vboxsync * Z-compare function into account, but we could skip loading the
040b4a09341f574825386333398110f4db3e1e51vboxsync * depthstencil for D3DCMP_NEVER and D3DCMP_ALWAYS as well. Also note
040b4a09341f574825386333398110f4db3e1e51vboxsync * that we never copy the stencil data.*/
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync DWORD location = context->render_offscreen ? SFLAG_DS_OFFSCREEN : SFLAG_DS_ONSCREEN;
040b4a09341f574825386333398110f4db3e1e51vboxsync if (This->stateBlock->renderState[WINED3DRS_ZWRITEENABLE]
040b4a09341f574825386333398110f4db3e1e51vboxsync || This->stateBlock->renderState[WINED3DRS_ZENABLE])
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync surface_load_ds_location(This->stencilBufferTarget, context, location);
040b4a09341f574825386333398110f4db3e1e51vboxsync if (This->stateBlock->renderState[WINED3DRS_ZWRITEENABLE])
040b4a09341f574825386333398110f4db3e1e51vboxsync surface_modify_ds_location(This->stencilBufferTarget, location);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Ok, we will be updating the screen from here onwards so grab the lock */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync GLenum glPrimType = This->stateBlock->gl_primitive_type;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync const struct wined3d_stream_info *stream_info = &This->strided_streams;
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync if (!This->strided_streams.position_transformed && context->num_untracked_materials
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync && This->stateBlock->renderState[WINED3DRS_LIGHTING])
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("Using software emulation because not all material properties could be tracked\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync TRACE("Using software emulation because not all material properties could be tracked\n");
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync else if (context->fog_coord && This->stateBlock->renderState[WINED3DRS_FOGENABLE])
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Either write a pipeline replacement shader or convert the specular alpha from unsigned byte
af062818b47340eef15700d2f0211576ba3506eevboxsync * to a float in the vertex buffer
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("Using software emulation because manual fog coordinates are provided\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync TRACE("Using software emulation because manual fog coordinates are provided\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync memcpy(&stridedlcl, &This->strided_streams, sizeof(stridedlcl));
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Immediate mode drawing */
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("Using immediate mode with vertex shaders for half float emulation\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync TRACE("Using immediate mode with vertex shaders for half float emulation\n");
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync drawStridedSlowVs(iface, stream_info, index_count, glPrimType, idxData, idxSize, StartIdx);
114410893548b9522c46fdcbd8f63385eb8bfb68vboxsync drawStridedSlow(iface, context, stream_info, index_count,
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Instancing emulation with mixing immediate mode and arrays */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync drawStridedInstanced(iface, &This->strided_streams, index_count,
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync drawStridedFast(iface, glPrimType, index_count, idxSize, idxData, StartIdx);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Finished updating the screen, restore lock */
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync wined3d_event_query_issue(This->buffer_queries[i], This);
ee6bcfc59fe3b0230aad85e2ef63d0402b7719b2vboxsync if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Diagnostics */
a3133ef29cdf3656735d569fd64e54c9286effc0vboxsync /* NOTE: set primCounter to the value reported by drawprim
af062818b47340eef15700d2f0211576ba3506eevboxsync before you want to to write frame makeup to /tmp */
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DSurface_LockRect(This->render_targets[0], &r, NULL, WINED3DLOCK_READONLY);
af062818b47340eef15700d2f0211576ba3506eevboxsync sprintf(buffer, "/tmp/backbuffer_%ld.tga", primCounter);
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DSurface_SaveSnapshot(This->render_targets[0], buffer);
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DSurface_UnlockRect(This->render_targets[0]);
af062818b47340eef15700d2f0211576ba3506eevboxsync for (textureNo = 0; textureNo < MAX_COMBINED_SAMPLERS; ++textureNo) {
af062818b47340eef15700d2f0211576ba3506eevboxsync if (This->stateBlock->textures[textureNo] != NULL) {
af062818b47340eef15700d2f0211576ba3506eevboxsync sprintf(buffer, "/tmp/texture_%p_%ld_%d.tga", This->stateBlock->textures[textureNo], primCounter, textureNo);
af062818b47340eef15700d2f0211576ba3506eevboxsync if (IWineD3DBaseTexture_GetType(This->stateBlock->textures[textureNo]) == WINED3DRTYPE_TEXTURE) {
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync IWineD3DTexture_GetSurfaceLevel(This->stateBlock->textures[textureNo], 0, &pSur);
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("base Texture isn't of type texture %d\n", IWineD3DBaseTexture_GetType(This->stateBlock->textures[textureNo]));
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Control goes back to the device, stateblock values may change again */
af062818b47340eef15700d2f0211576ba3506eevboxsync float length = n[0] * n[0] + n[1] * n[1] + n[2] * n[2];
af062818b47340eef15700d2f0211576ba3506eevboxsync n[0] = n[0] / length;
af062818b47340eef15700d2f0211576ba3506eevboxsync/* Tesselates a high order rectangular patch into single triangles using gl evaluators
af062818b47340eef15700d2f0211576ba3506eevboxsync * The problem is that OpenGL does not offer a direct way to return the tesselated primitives,
af062818b47340eef15700d2f0211576ba3506eevboxsync * and they can't be sent off for rendering directly either. Tesselating is slow, so we want
af062818b47340eef15700d2f0211576ba3506eevboxsync * to cache the patches in a vertex buffer. But more importantly, gl can't bind generated
af062818b47340eef15700d2f0211576ba3506eevboxsync * attributes to numbered shader attributes, so we have to store them and rebind them as needed
af062818b47340eef15700d2f0211576ba3506eevboxsync * in drawprim.
af062818b47340eef15700d2f0211576ba3506eevboxsync * To read back, the opengl feedback mode is used. This creates a problem because we want
af062818b47340eef15700d2f0211576ba3506eevboxsync * untransformed, unlit vertices, but feedback runs everything through transform and lighting.
af062818b47340eef15700d2f0211576ba3506eevboxsync * Thus disable lighting and set identity matrices to get unmodified colors and positions.
af062818b47340eef15700d2f0211576ba3506eevboxsync * To overcome clipping find the biggest x, y and z values of the vertices in the patch and scale
af062818b47340eef15700d2f0211576ba3506eevboxsync * them to [-1.0;+1.0] and set the viewport up to scale them back.
af062818b47340eef15700d2f0211576ba3506eevboxsync * Normals are more tricky: Draw white vertices with 3 directional lights, and calculate the
af062818b47340eef15700d2f0211576ba3506eevboxsync * resulting colors back to the normals.
af062818b47340eef15700d2f0211576ba3506eevboxsync * NOTE: This function activates a context for blitting, modifies matrices & viewport, but
af062818b47340eef15700d2f0211576ba3506eevboxsync * does not restore it because normally a draw follows immediately afterwards. The caller is
af062818b47340eef15700d2f0211576ba3506eevboxsync * responsible of taking care that either the gl states are restored, or the context activated
af062818b47340eef15700d2f0211576ba3506eevboxsync * for drawing to reset the lastWasBlit flag.
af062818b47340eef15700d2f0211576ba3506eevboxsyncHRESULT tesselate_rectpatch(IWineD3DDeviceImpl *This,
af062818b47340eef15700d2f0211576ba3506eevboxsync unsigned int i, j, num_quads, out_vertex_size, buffer_size, d3d_out_vertex_size;
040b4a09341f574825386333398110f4db3e1e51vboxsync float max_x = 0.0f, max_y = 0.0f, max_z = 0.0f, neg_z = 0.0f;
af062818b47340eef15700d2f0211576ba3506eevboxsync const WINED3DRECTPATCH_INFO *info = &patch->RectPatchInfo;
040b4a09341f574825386333398110f4db3e1e51vboxsync /* Simply activate the context for blitting. This disables all the things we don't want and
040b4a09341f574825386333398110f4db3e1e51vboxsync * takes care of dirtifying. Dirtifying is preferred over pushing / popping, since drawing the
040b4a09341f574825386333398110f4db3e1e51vboxsync * patch (as opposed to normal draws) will most likely need different changes anyway. */
5112e32d7072e280613921c982a6672f2c859cf3vboxsync context = context_acquire(This, NULL, CTXUSAGE_BLIT);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* First, locate the position data. This is provided in a vertex buffer in the stateblock.
af062818b47340eef15700d2f0211576ba3506eevboxsync * Beware of vbos
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync device_stream_info_from_declaration(This, FALSE, &stream_info, NULL);
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync vb = (struct wined3d_buffer *)This->stateBlock->streamSource[e->stream_idx];
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync e->data = (BYTE *)((unsigned long)e->data + (unsigned long)buffer_get_sysmem(vb));
af062818b47340eef15700d2f0211576ba3506eevboxsync vtxStride * info->Stride * info->StartVertexOffsetHeight +
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Not entirely sure about what happens with transformed vertices */
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync if (stream_info.position_transformed) FIXME("Transformed position in rectpatch generation\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync /* glMap2f reads vertex sizes in GLfloats, the d3d stride is in bytes.
af062818b47340eef15700d2f0211576ba3506eevboxsync * I don't see how the stride could not be a multiple of 4, but make sure
af062818b47340eef15700d2f0211576ba3506eevboxsync * to check it
af062818b47340eef15700d2f0211576ba3506eevboxsync ERR("Vertex stride is not a multiple of sizeof(GLfloat)\n");
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("Basis is %s, how to handle this?\n", debug_d3dbasis(info->Basis));
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("Degree is %s, how to handle this?\n", debug_d3ddegree(info->Degree));
af062818b47340eef15700d2f0211576ba3506eevboxsync /* First, get the boundary cube of the input data */
af062818b47340eef15700d2f0211576ba3506eevboxsync const float *v = (const float *)(data + vtxStride * i + vtxStride * info->Stride * j);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* This needs some improvements in the vertex decl code */
af062818b47340eef15700d2f0211576ba3506eevboxsync FIXME("Cannot find data to generate. Only generating position and normals\n");
040b4a09341f574825386333398110f4db3e1e51vboxsync glScalef(1.0f / (max_x), 1.0f / (max_y), max_z == 0.0f ? 1.0f : 1.0f / (2.0f * max_z));
af062818b47340eef15700d2f0211576ba3506eevboxsync glViewport(-max_x, -max_y, 2 * (max_x), 2 * (max_y));
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Some states to take care of. If we're in wireframe opengl will produce lines, and confuse
af062818b47340eef15700d2f0211576ba3506eevboxsync * our feedback buffer parser
af062818b47340eef15700d2f0211576ba3506eevboxsync checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_FILLMODE));
040b4a09341f574825386333398110f4db3e1e51vboxsync static const GLfloat black[] = {0.0f, 0.0f, 0.0f, 0.0f};
040b4a09341f574825386333398110f4db3e1e51vboxsync static const GLfloat red[] = {1.0f, 0.0f, 0.0f, 0.0f};
040b4a09341f574825386333398110f4db3e1e51vboxsync static const GLfloat green[] = {0.0f, 1.0f, 0.0f, 0.0f};
040b4a09341f574825386333398110f4db3e1e51vboxsync static const GLfloat blue[] = {0.0f, 0.0f, 1.0f, 0.0f};
040b4a09341f574825386333398110f4db3e1e51vboxsync static const GLfloat white[] = {1.0f, 1.0f, 1.0f, 1.0f};
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_AMBIENT));
5112e32d7072e280613921c982a6672f2c859cf3vboxsync for (i = 3; i < context->gl_info->limits.lights; ++i)
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(i));
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(0));
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(1));
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(2));
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl_MarkStateDirty(This, STATE_MATERIAL);
af062818b47340eef15700d2f0211576ba3506eevboxsync IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORVERTEX));
af062818b47340eef15700d2f0211576ba3506eevboxsync glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, black);
af062818b47340eef15700d2f0211576ba3506eevboxsync glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, black);
af062818b47340eef15700d2f0211576ba3506eevboxsync glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, white);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Enable the needed maps.
af062818b47340eef15700d2f0211576ba3506eevboxsync * GL_MAP2_VERTEX_3 is needed for positional data.
af062818b47340eef15700d2f0211576ba3506eevboxsync * GL_AUTO_NORMAL to generate normals from the position. Do not use GL_MAP2_NORMAL.
af062818b47340eef15700d2f0211576ba3506eevboxsync * GL_MAP2_TEXTURE_COORD_4 for texture coords
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync num_quads = ceilf(patch->numSegs[0]) * ceilf(patch->numSegs[1]);
af062818b47340eef15700d2f0211576ba3506eevboxsync buffer_size = num_quads * out_vertex_size * 2 /* triangle list */ * 3 /* verts per tri */
af062818b47340eef15700d2f0211576ba3506eevboxsync + 4 * num_quads /* 2 triangle markers per quad + num verts in tri */;
af062818b47340eef15700d2f0211576ba3506eevboxsync feedbuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buffer_size * sizeof(float) * 8);
040b4a09341f574825386333398110f4db3e1e51vboxsync 0.0f, 1.0f, vtxStride / sizeof(float), info->Width,
040b4a09341f574825386333398110f4db3e1e51vboxsync 0.0f, 1.0f, info->Stride * vtxStride / sizeof(float), info->Height,
040b4a09341f574825386333398110f4db3e1e51vboxsync 0.0f, 1.0f, vtxStride / sizeof(float), info->Width,
040b4a09341f574825386333398110f4db3e1e51vboxsync 0.0f, 1.0f, info->Stride * vtxStride / sizeof(float), info->Height,
040b4a09341f574825386333398110f4db3e1e51vboxsync glMapGrid2f(ceilf(patch->numSegs[0]), 0.0f, 1.0f, ceilf(patch->numSegs[1]), 0.0f, 1.0f);
af062818b47340eef15700d2f0211576ba3506eevboxsync glFeedbackBuffer(buffer_size * 2, feedback_type, feedbuffer);
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync glEvalMesh2(GL_FILL, 0, ceilf(patch->numSegs[0]), 0, ceilf(patch->numSegs[1]));
af062818b47340eef15700d2f0211576ba3506eevboxsync if(i == -1) {
af062818b47340eef15700d2f0211576ba3506eevboxsync ERR("Feedback failed. Expected %d elements back\n", buffer_size);
af062818b47340eef15700d2f0211576ba3506eevboxsync } else if(i != buffer_size) {
af062818b47340eef15700d2f0211576ba3506eevboxsync ERR("Unexpected amount of elements returned. Expected %d, got %d\n", buffer_size, i);
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, num_quads * 6 * d3d_out_vertex_size * sizeof(float) * 8);
af062818b47340eef15700d2f0211576ba3506eevboxsync for(j = 0; j < buffer_size; j += (3 /* num verts */ * out_vertex_size + 2 /* tri marker */)) {
af062818b47340eef15700d2f0211576ba3506eevboxsync ERR("Unexpected polygon: %f corners\n", feedbuffer[j + 1]);
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Somehow there are different ideas about back / front facing, so fix up the
af062818b47340eef15700d2f0211576ba3506eevboxsync * vertex order
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 2 + 2]; /* x, triangle 2 */
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 2 + 3]; /* y, triangle 2 */
040b4a09341f574825386333398110f4db3e1e51vboxsync patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 2 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 3 */
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 2 + 5];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 2 + 6];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 2 + 7];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 1 + 2]; /* x, triangle 2 */
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 1 + 3]; /* y, triangle 2 */
040b4a09341f574825386333398110f4db3e1e51vboxsync patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 1 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 2 */
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 1 + 5];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 1 + 6];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 1 + 7];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 0 + 2]; /* x, triangle 1 */
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 0 + 3]; /* y, triangle 1 */
040b4a09341f574825386333398110f4db3e1e51vboxsync patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 0 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 1 */
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 0 + 5];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 0 + 6];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 0 + 7];
af062818b47340eef15700d2f0211576ba3506eevboxsync /* Now do the same with reverse light directions */
040b4a09341f574825386333398110f4db3e1e51vboxsync static const GLfloat x[] = {-1.0f, 0.0f, 0.0f, 0.0f};
040b4a09341f574825386333398110f4db3e1e51vboxsync static const GLfloat y[] = { 0.0f, -1.0f, 0.0f, 0.0f};
040b4a09341f574825386333398110f4db3e1e51vboxsync static const GLfloat z[] = { 0.0f, 0.0f, -1.0f, 0.0f};
040b4a09341f574825386333398110f4db3e1e51vboxsync checkGLcall("Setting up reverse light directions");
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync glEvalMesh2(GL_FILL, 0, ceilf(patch->numSegs[0]), 0, ceilf(patch->numSegs[1]));
af062818b47340eef15700d2f0211576ba3506eevboxsync for(j = 0; j < buffer_size; j += (3 /* num verts */ * out_vertex_size + 2 /* tri marker */)) {
af062818b47340eef15700d2f0211576ba3506eevboxsync ERR("Unexpected polygon: %f corners\n", feedbuffer[j + 1]);
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 2 + 5];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 2 + 6];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 2 + 7];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 1 + 5];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 1 + 6];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 1 + 7];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 0 + 5];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 0 + 6];
af062818b47340eef15700d2f0211576ba3506eevboxsync patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 0 + 7];
5112e32d7072e280613921c982a6672f2c859cf3vboxsync memset(&patch->strided, 0, sizeof(patch->strided));
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync patch->strided.position.format = WINED3DFMT_R32G32B32_FLOAT;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync patch->strided.position.lpData = (BYTE *) patch->mem;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync patch->strided.normal.format = WINED3DFMT_R32G32B32_FLOAT;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync patch->strided.normal.lpData = (BYTE *) patch->mem + 3 * sizeof(float) /* pos */;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync patch->strided.texCoords[0].format = WINED3DFMT_R32G32B32A32_FLOAT;
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync patch->strided.texCoords[0].lpData = (BYTE *) patch->mem + 3 * sizeof(float) /* pos */;