Skip to content

W
wine-winehq
Commit 149a85c2 authored by Stefan Dösinger's avatar Stefan Dösinger Committed by Alexandre Julliard
Browse files
Options

d3d: Remove high level patch support.

No Windows driver ever exposed this, and no game uses this. The only application that used this feature is a DirectX 8 SDK sample.
parent d7e5189c
Show whitespace changes
Inline Side-by-side
Showing with 13 additions and 644 deletions
dlls/d3d8/device.c
View file @ 149a85c2
......@@ -2711,49 +2711,23 @@ static HRESULT WINAPI d3d8_device_GetPixelShaderFunction(IDirect3DDevice8 *iface
static HRESULT WINAPI d3d8_device_DrawRectPatch(IDirect3DDevice8 *iface, UINT handle,
const float *segment_count, const D3DRECTPATCH_INFO *patch_info)
{
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
HRESULT hr;
TRACE("iface %p, handle %#x, segment_count %p, patch_info %p.\n",
FIXME("iface %p, handle %#x, segment_count %p, patch_info %p unimplemented.\n",
iface, handle, segment_count, patch_info);
wined3d_mutex_lock();
hr = wined3d_device_draw_rect_patch(device->wined3d_device, handle,
segment_count, (const struct wined3d_rect_patch_info *)patch_info);
wined3d_mutex_unlock();
return hr;
return D3D_OK;
}
static HRESULT WINAPI d3d8_device_DrawTriPatch(IDirect3DDevice8 *iface, UINT handle,
const float *segment_count, const D3DTRIPATCH_INFO *patch_info)
{
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
HRESULT hr;
TRACE("iface %p, handle %#x, segment_count %p, patch_info %p.\n",
FIXME("iface %p, handle %#x, segment_count %p, patch_info %p unimplemented.\n",
iface, handle, segment_count, patch_info);
wined3d_mutex_lock();
hr = wined3d_device_draw_tri_patch(device->wined3d_device, handle,
segment_count, (const struct wined3d_tri_patch_info *)patch_info);
wined3d_mutex_unlock();
return hr;
return D3D_OK;
}
static HRESULT WINAPI d3d8_device_DeletePatch(IDirect3DDevice8 *iface, UINT handle)
{
struct d3d8_device *device = impl_from_IDirect3DDevice8(iface);
HRESULT hr;
TRACE("iface %p, handle %#x.\n", iface, handle);
wined3d_mutex_lock();
hr = wined3d_device_delete_patch(device->wined3d_device, handle);
wined3d_mutex_unlock();
return hr;
FIXME("iface %p, handle %#x unimplemented.\n", iface, handle);
return D3DERR_INVALIDCALL;
}
static HRESULT WINAPI d3d8_device_SetStreamSource(IDirect3DDevice8 *iface,
......
dlls/d3d9/device.c
View file @ 149a85c2
......@@ -2867,49 +2867,23 @@ static HRESULT WINAPI d3d9_device_GetPixelShaderConstantB(IDirect3DDevice9Ex *if
static HRESULT WINAPI d3d9_device_DrawRectPatch(IDirect3DDevice9Ex *iface, UINT handle,
const float *segment_count, const D3DRECTPATCH_INFO *patch_info)
{
struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface);
HRESULT hr;
TRACE("iface %p, handle %#x, segment_count %p, patch_info %p.\n",
FIXME("iface %p, handle %#x, segment_count %p, patch_info %p unimplemented.\n",
iface, handle, segment_count, patch_info);
wined3d_mutex_lock();
hr = wined3d_device_draw_rect_patch(device->wined3d_device, handle,
segment_count, (const struct wined3d_rect_patch_info *)patch_info);
wined3d_mutex_unlock();
return hr;
return D3D_OK;
}
static HRESULT WINAPI d3d9_device_DrawTriPatch(IDirect3DDevice9Ex *iface, UINT handle,
const float *segment_count, const D3DTRIPATCH_INFO *patch_info)
{
struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface);
HRESULT hr;
TRACE("iface %p, handle %#x, segment_count %p, patch_info %p.\n",
FIXME("iface %p, handle %#x, segment_count %p, patch_info %p unimplemented.\n",
iface, handle, segment_count, patch_info);
wined3d_mutex_lock();
hr = wined3d_device_draw_tri_patch(device->wined3d_device, handle,
segment_count, (const struct wined3d_tri_patch_info *)patch_info);
wined3d_mutex_unlock();
return hr;
return D3D_OK;
}
static HRESULT WINAPI d3d9_device_DeletePatch(IDirect3DDevice9Ex *iface, UINT handle)
{
struct d3d9_device *device = impl_from_IDirect3DDevice9Ex(iface);
HRESULT hr;
TRACE("iface %p, handle %#x.\n", iface, handle);
wined3d_mutex_lock();
hr = wined3d_device_delete_patch(device->wined3d_device, handle);
wined3d_mutex_unlock();
return hr;
FIXME("iface %p, handle %#x unimplemented.\n", iface, handle);
return D3DERR_INVALIDCALL;
}
static HRESULT WINAPI d3d9_device_CreateQuery(IDirect3DDevice9Ex *iface, D3DQUERYTYPE type, IDirect3DQuery9 **query)
......
dlls/wined3d/device.c
View file @ 149a85c2
......@@ -1390,19 +1390,6 @@ HRESULT CDECL wined3d_device_uninit_3d(struct wined3d_device *device)
resource->resource_ops->resource_unload(resource);
}
TRACE("Deleting high order patches\n");
for (i = 0; i < PATCHMAP_SIZE; ++i)
{
struct wined3d_rect_patch *patch;
struct list *e1, *e2;
LIST_FOR_EACH_SAFE(e1, e2, &device->patches[i])
{
patch = LIST_ENTRY(e1, struct wined3d_rect_patch, entry);
wined3d_device_delete_patch(device, patch->Handle);
}
}
/* Delete the mouse cursor texture */
if (device->cursorTexture)
{
......@@ -4489,140 +4476,6 @@ HRESULT CDECL wined3d_device_update_surface(struct wined3d_device *device,
return surface_upload_from_surface(dst_surface, dst_point, src_surface, src_rect);
}
HRESULT CDECL wined3d_device_draw_rect_patch(struct wined3d_device *device, UINT handle,
const float *num_segs, const struct wined3d_rect_patch_info *rect_patch_info)
{
struct wined3d_rect_patch *patch;
GLenum old_primitive_type;
unsigned int i;
struct list *e;
BOOL found;
TRACE("device %p, handle %#x, num_segs %p, rect_patch_info %p.\n",
device, handle, num_segs, rect_patch_info);
if (!(handle || rect_patch_info))
{
/* TODO: Write a test for the return value, thus the FIXME */
FIXME("Both handle and rect_patch_info are NULL.\n");
return WINED3DERR_INVALIDCALL;
}
if (handle)
{
i = PATCHMAP_HASHFUNC(handle);
found = FALSE;
LIST_FOR_EACH(e, &device->patches[i])
{
patch = LIST_ENTRY(e, struct wined3d_rect_patch, entry);
if (patch->Handle == handle)
{
found = TRUE;
break;
}
}
if (!found)
{
TRACE("Patch does not exist. Creating a new one\n");
patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
patch->Handle = handle;
list_add_head(&device->patches[i], &patch->entry);
} else {
TRACE("Found existing patch %p\n", patch);
}
}
else
{
/* Since opengl does not load tesselated vertex attributes into numbered vertex
* attributes we have to tesselate, read back, and draw. This needs a patch
* management structure instance. Create one.
*
* A possible improvement is to check if a vertex shader is used, and if not directly
* draw the patch.
*/
FIXME("Drawing an uncached patch. This is slow\n");
patch = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*patch));
}
if (num_segs[0] != patch->numSegs[0] || num_segs[1] != patch->numSegs[1]
|| num_segs[2] != patch->numSegs[2] || num_segs[3] != patch->numSegs[3]
|| (rect_patch_info && memcmp(rect_patch_info, &patch->rect_patch_info, sizeof(*rect_patch_info))))
{
HRESULT hr;
TRACE("Tesselation density or patch info changed, retesselating\n");
if (rect_patch_info)
patch->rect_patch_info = *rect_patch_info;
patch->numSegs[0] = num_segs[0];
patch->numSegs[1] = num_segs[1];
patch->numSegs[2] = num_segs[2];
patch->numSegs[3] = num_segs[3];
hr = tesselate_rectpatch(device, patch);
if (FAILED(hr))
{
WARN("Patch tesselation failed.\n");
/* Do not release the handle to store the params of the patch */
if (!handle)
HeapFree(GetProcessHeap(), 0, patch);
return hr;
}
}
old_primitive_type = device->stateBlock->state.gl_primitive_type;
device->stateBlock->state.gl_primitive_type = GL_TRIANGLES;
wined3d_device_draw_primitive_strided(device, patch->numSegs[0] * patch->numSegs[1] * 2 * 3, &patch->strided);
device->stateBlock->state.gl_primitive_type = old_primitive_type;
/* Destroy uncached patches */
if (!handle)
{
HeapFree(GetProcessHeap(), 0, patch->mem);
HeapFree(GetProcessHeap(), 0, patch);
}
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_draw_tri_patch(struct wined3d_device *device, UINT handle,
const float *segment_count, const struct wined3d_tri_patch_info *patch_info)
{
FIXME("device %p, handle %#x, segment_count %p, patch_info %p stub!\n",
device, handle, segment_count, patch_info);
return WINED3D_OK;
}
HRESULT CDECL wined3d_device_delete_patch(struct wined3d_device *device, UINT handle)
{
struct wined3d_rect_patch *patch;
struct list *e;
int i;
TRACE("device %p, handle %#x.\n", device, handle);
i = PATCHMAP_HASHFUNC(handle);
LIST_FOR_EACH(e, &device->patches[i])
{
patch = LIST_ENTRY(e, struct wined3d_rect_patch, entry);
if (patch->Handle == handle)
{
TRACE("Deleting patch %p\n", patch);
list_remove(&patch->entry);
HeapFree(GetProcessHeap(), 0, patch->mem);
HeapFree(GetProcessHeap(), 0, patch);
return WINED3D_OK;
}
}
/* TODO: Write a test for the return value */
FIXME("Attempt to destroy nonexistent patch\n");
return WINED3DERR_INVALIDCALL;
}
/* Do not call while under the GL lock. */
HRESULT CDECL wined3d_device_color_fill(struct wined3d_device *device,
struct wined3d_surface *surface, const RECT *rect, const struct wined3d_color *color)
......@@ -5656,8 +5509,6 @@ HRESULT device_init(struct wined3d_device *device, struct wined3d *wined3d,
device->create_parms.focus_window = focus_window;
device->create_parms.flags = flags;
for (i = 0; i < PATCHMAP_SIZE; ++i) list_init(&device->patches[i]);
device->shader_backend = adapter->shader_backend;
device->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps);
device->vs_version = shader_caps.vs_version;
......
dlls/wined3d/directx.c
View file @ 149a85c2
......@@ -4491,8 +4491,7 @@ HRESULT CDECL wined3d_get_device_caps(const struct wined3d *wined3d, UINT adapte
WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
WINED3DDEVCAPS_CANRENDERAFTERFLIP |
WINED3DDEVCAPS_DRAWPRIMITIVES2 |
WINED3DDEVCAPS_DRAWPRIMITIVES2EX |
WINED3DDEVCAPS_RTPATCHES;
WINED3DDEVCAPS_DRAWPRIMITIVES2EX;
caps->PrimitiveMiscCaps = WINED3DPMISCCAPS_CULLNONE |
WINED3DPMISCCAPS_CULLCCW |
......
dlls/wined3d/drawprim.c
View file @ 149a85c2
......@@ -779,403 +779,3 @@ void draw_primitive(struct wined3d_device *device, UINT start_idx, UINT index_co
/* Control goes back to the device, stateblock values may change again */
device->isInDraw = FALSE;
}
static void normalize_normal(float *n) {
float length = n[0] * n[0] + n[1] * n[1] + n[2] * n[2];
if (length == 0.0f) return;
length = sqrtf(length);
n[0] = n[0] / length;
n[1] = n[1] / length;
n[2] = n[2] / length;
}
/* Tesselates a high order rectangular patch into single triangles using gl evaluators
*
* The problem is that OpenGL does not offer a direct way to return the tesselated primitives,
* and they can't be sent off for rendering directly either. Tesselating is slow, so we want
* to cache the patches in a vertex buffer. But more importantly, gl can't bind generated
* attributes to numbered shader attributes, so we have to store them and rebind them as needed
* in drawprim.
*
* To read back, the opengl feedback mode is used. This creates a problem because we want
* untransformed, unlit vertices, but feedback runs everything through transform and lighting.
* Thus disable lighting and set identity matrices to get unmodified colors and positions.
* To overcome clipping find the biggest x, y and z values of the vertices in the patch and scale
* them to [-1.0;+1.0] and set the viewport up to scale them back.
*
* Normals are more tricky: Draw white vertices with 3 directional lights, and calculate the
* resulting colors back to the normals.
*
* NOTE: This function activates a context for blitting, modifies matrices & viewport, but
* does not restore it because normally a draw follows immediately afterwards. The caller is
* responsible of taking care that either the gl states are restored, or the context activated
* for drawing to reset the lastWasBlit flag.
*/
HRESULT tesselate_rectpatch(struct wined3d_device *This, struct wined3d_rect_patch *patch)
{
unsigned int i, j, num_quads, out_vertex_size, buffer_size, d3d_out_vertex_size;
const struct wined3d_rect_patch_info *info = &patch->rect_patch_info;
float max_x = 0.0f, max_y = 0.0f, max_z = 0.0f, neg_z = 0.0f;
struct wined3d_state *state = &This->stateBlock->state;
struct wined3d_stream_info stream_info;
struct wined3d_stream_info_element *e;
const struct wined3d_gl_info *gl_info;
struct wined3d_context *context;
struct wined3d_shader *vs;
const BYTE *data;
DWORD vtxStride;
GLenum feedback_type;
GLfloat *feedbuffer;
/* Simply activate the context for blitting. This disables all the things we don't want and
* takes care of dirtifying. Dirtifying is preferred over pushing / popping, since drawing the
* patch (as opposed to normal draws) will most likely need different changes anyway. */
context = context_acquire(This, NULL);
gl_info = context->gl_info;
context_apply_blit_state(context, This);
/* First, locate the position data. This is provided in a vertex buffer in
* the stateblock. Beware of VBOs. */
vs = state->vertex_shader;
state->vertex_shader = NULL;
device_stream_info_from_declaration(This, &stream_info);
state->vertex_shader = vs;
e = &stream_info.elements[WINED3D_FFP_POSITION];
if (e->data.buffer_object)
{
struct wined3d_buffer *vb = state->streams[e->stream_idx].buffer;
e->data.addr = (BYTE *)((ULONG_PTR)e->data.addr + (ULONG_PTR)buffer_get_sysmem(vb, context->gl_info));
}
vtxStride = e->stride;
data = e->data.addr
+ vtxStride * info->stride * info->start_vertex_offset_height
+ vtxStride * info->start_vertex_offset_width;
/* Not entirely sure about what happens with transformed vertices */
if (stream_info.position_transformed) FIXME("Transformed position in rectpatch generation\n");
if(vtxStride % sizeof(GLfloat)) {
/* glMap2f reads vertex sizes in GLfloats, the d3d stride is in bytes.
* I don't see how the stride could not be a multiple of 4, but make sure
* to check it
*/
ERR("Vertex stride is not a multiple of sizeof(GLfloat)\n");
}
if (info->basis != WINED3D_BASIS_BEZIER)
FIXME("Basis is %s, how to handle this?\n", debug_d3dbasis(info->basis));
if (info->degree != WINED3D_DEGREE_CUBIC)
FIXME("Degree is %s, how to handle this?\n", debug_d3ddegree(info->degree));
/* First, get the boundary cube of the input data */
for (j = 0; j < info->height; ++j)
{
for (i = 0; i < info->width; ++i)
{
const float *v = (const float *)(data + vtxStride * i + vtxStride * info->stride * j);
if(fabs(v[0]) > max_x) max_x = fabsf(v[0]);
if(fabs(v[1]) > max_y) max_y = fabsf(v[1]);
if(fabs(v[2]) > max_z) max_z = fabsf(v[2]);
if(v[2] < neg_z) neg_z = v[2];
}
}
/* This needs some improvements in the vertex decl code */
FIXME("Cannot find data to generate. Only generating position and normals\n");
patch->has_normals = TRUE;
patch->has_texcoords = FALSE;
gl_info->gl_ops.gl.p_glMatrixMode(GL_PROJECTION);
checkGLcall("glMatrixMode(GL_PROJECTION)");
gl_info->gl_ops.gl.p_glLoadIdentity();
checkGLcall("glLoadIdentity()");
gl_info->gl_ops.gl.p_glScalef(1.0f / (max_x), 1.0f / (max_y), max_z == 0.0f ? 1.0f : 1.0f / (2.0f * max_z));
gl_info->gl_ops.gl.p_glTranslatef(0.0f, 0.0f, 0.5f);
checkGLcall("glScalef");
gl_info->gl_ops.gl.p_glViewport(-max_x, -max_y, 2 * (max_x), 2 * (max_y));
checkGLcall("glViewport");
/* Some states to take care of. If we're in wireframe opengl will produce lines, and confuse
* our feedback buffer parser
*/
gl_info->gl_ops.gl.p_glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
context_invalidate_state(context, STATE_RENDER(WINED3D_RS_FILLMODE));
if (patch->has_normals)
{
static const GLfloat black[] = {0.0f, 0.0f, 0.0f, 0.0f};
static const GLfloat red[] = {1.0f, 0.0f, 0.0f, 0.0f};
static const GLfloat green[] = {0.0f, 1.0f, 0.0f, 0.0f};
static const GLfloat blue[] = {0.0f, 0.0f, 1.0f, 0.0f};
static const GLfloat white[] = {1.0f, 1.0f, 1.0f, 1.0f};
gl_info->gl_ops.gl.p_glEnable(GL_LIGHTING);
checkGLcall("glEnable(GL_LIGHTING)");
gl_info->gl_ops.gl.p_glLightModelfv(GL_LIGHT_MODEL_AMBIENT, black);
checkGLcall("glLightModel for MODEL_AMBIENT");
context_invalidate_state(context, STATE_RENDER(WINED3D_RS_AMBIENT));
for (i = 3; i < context->gl_info->limits.lights; ++i)
{
gl_info->gl_ops.gl.p_glDisable(GL_LIGHT0 + i);
checkGLcall("glDisable(GL_LIGHT0 + i)");
context_invalidate_state(context, STATE_ACTIVELIGHT(i));
}
context_invalidate_state(context, STATE_ACTIVELIGHT(0));
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT0, GL_DIFFUSE, red);
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT0, GL_SPECULAR, black);
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT0, GL_AMBIENT, black);
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT0, GL_POSITION, red);
gl_info->gl_ops.gl.p_glEnable(GL_LIGHT0);
checkGLcall("Setting up light 1");
context_invalidate_state(context, STATE_ACTIVELIGHT(1));
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT1, GL_DIFFUSE, green);
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT1, GL_SPECULAR, black);
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT1, GL_AMBIENT, black);
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT1, GL_POSITION, green);
gl_info->gl_ops.gl.p_glEnable(GL_LIGHT1);
checkGLcall("Setting up light 2");
context_invalidate_state(context, STATE_ACTIVELIGHT(2));
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT2, GL_DIFFUSE, blue);
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT2, GL_SPECULAR, black);
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT2, GL_AMBIENT, black);
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT2, GL_POSITION, blue);
gl_info->gl_ops.gl.p_glEnable(GL_LIGHT2);
checkGLcall("Setting up light 3");
context_invalidate_state(context, STATE_MATERIAL);
context_invalidate_state(context, STATE_RENDER(WINED3D_RS_COLORVERTEX));
gl_info->gl_ops.gl.p_glDisable(GL_COLOR_MATERIAL);
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, black);
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, black);
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, white);
checkGLcall("Setting up materials");
}
/* Enable the needed maps.
* GL_MAP2_VERTEX_3 is needed for positional data.
* GL_AUTO_NORMAL to generate normals from the position. Do not use GL_MAP2_NORMAL.
* GL_MAP2_TEXTURE_COORD_4 for texture coords
*/
num_quads = ceilf(patch->numSegs[0]) * ceilf(patch->numSegs[1]);
out_vertex_size = 3 /* position */;
d3d_out_vertex_size = 3;
gl_info->gl_ops.gl.p_glEnable(GL_MAP2_VERTEX_3);
if (patch->has_normals && patch->has_texcoords)
{
FIXME("Texcoords not handled yet\n");
feedback_type = GL_3D_COLOR_TEXTURE;
out_vertex_size += 8;
d3d_out_vertex_size += 7;
gl_info->gl_ops.gl.p_glEnable(GL_AUTO_NORMAL);
gl_info->gl_ops.gl.p_glEnable(GL_MAP2_TEXTURE_COORD_4);
}
else if (patch->has_texcoords)
{
FIXME("Texcoords not handled yet\n");
feedback_type = GL_3D_COLOR_TEXTURE;
out_vertex_size += 7;
d3d_out_vertex_size += 4;
gl_info->gl_ops.gl.p_glEnable(GL_MAP2_TEXTURE_COORD_4);
}
else if (patch->has_normals)
{
feedback_type = GL_3D_COLOR;
out_vertex_size += 4;
d3d_out_vertex_size += 3;
gl_info->gl_ops.gl.p_glEnable(GL_AUTO_NORMAL);
}
else
{
feedback_type = GL_3D;
}
checkGLcall("glEnable vertex attrib generation");
buffer_size = num_quads * out_vertex_size * 2 /* triangle list */ * 3 /* verts per tri */
+ 4 * num_quads /* 2 triangle markers per quad + num verts in tri */;
feedbuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buffer_size * sizeof(float) * 8);
gl_info->gl_ops.gl.p_glMap2f(GL_MAP2_VERTEX_3,
0.0f, 1.0f, vtxStride / sizeof(float), info->width,
0.0f, 1.0f, info->stride * vtxStride / sizeof(float), info->height,
(const GLfloat *)data);
checkGLcall("glMap2f");
if (patch->has_texcoords)
{
gl_info->gl_ops.gl.p_glMap2f(GL_MAP2_TEXTURE_COORD_4,
0.0f, 1.0f, vtxStride / sizeof(float), info->width,
0.0f, 1.0f, info->stride * vtxStride / sizeof(float), info->height,
(const GLfloat *)data);
checkGLcall("glMap2f");
}
gl_info->gl_ops.gl.p_glMapGrid2f(ceilf(patch->numSegs[0]), 0.0f, 1.0f, ceilf(patch->numSegs[1]), 0.0f, 1.0f);
checkGLcall("glMapGrid2f");
gl_info->gl_ops.gl.p_glFeedbackBuffer(buffer_size * 2, feedback_type, feedbuffer);
checkGLcall("glFeedbackBuffer");
gl_info->gl_ops.gl.p_glRenderMode(GL_FEEDBACK);
gl_info->gl_ops.gl.p_glEvalMesh2(GL_FILL, 0, ceilf(patch->numSegs[0]), 0, ceilf(patch->numSegs[1]));
checkGLcall("glEvalMesh2");
i = gl_info->gl_ops.gl.p_glRenderMode(GL_RENDER);
if (i == -1)
{
ERR("Feedback failed. Expected %d elements back\n", buffer_size);
HeapFree(GetProcessHeap(), 0, feedbuffer);
context_release(context);
return WINED3DERR_DRIVERINTERNALERROR;
}
else if (i != buffer_size)
{
ERR("Unexpected amount of elements returned. Expected %d, got %d\n", buffer_size, i);
HeapFree(GetProcessHeap(), 0, feedbuffer);
context_release(context);
return WINED3DERR_DRIVERINTERNALERROR;
}
else
{
TRACE("Got %d elements as expected\n", i);
}
HeapFree(GetProcessHeap(), 0, patch->mem);
patch->mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, num_quads * 6 * d3d_out_vertex_size * sizeof(float) * 8);
i = 0;
for(j = 0; j < buffer_size; j += (3 /* num verts */ * out_vertex_size + 2 /* tri marker */)) {
if(feedbuffer[j] != GL_POLYGON_TOKEN) {
ERR("Unexpected token: %f\n", feedbuffer[j]);
continue;
}
if(feedbuffer[j + 1] != 3) {
ERR("Unexpected polygon: %f corners\n", feedbuffer[j + 1]);
continue;
}
/* Somehow there are different ideas about back / front facing, so fix up the
* vertex order
*/
patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 2 + 2]; /* x, triangle 2 */
patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 2 + 3]; /* y, triangle 2 */
patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 2 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 3 */
if(patch->has_normals) {
patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 2 + 5];
patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 2 + 6];
patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 2 + 7];
}
i += d3d_out_vertex_size;
patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 1 + 2]; /* x, triangle 2 */
patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 1 + 3]; /* y, triangle 2 */
patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 1 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 2 */
if(patch->has_normals) {
patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 1 + 5];
patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 1 + 6];
patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 1 + 7];
}
i += d3d_out_vertex_size;
patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 0 + 2]; /* x, triangle 1 */
patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 0 + 3]; /* y, triangle 1 */
patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 0 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 1 */
if(patch->has_normals) {
patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 0 + 5];
patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 0 + 6];
patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 0 + 7];
}
i += d3d_out_vertex_size;
}
if(patch->has_normals) {
/* Now do the same with reverse light directions */
static const GLfloat x[] = {-1.0f, 0.0f, 0.0f, 0.0f};
static const GLfloat y[] = { 0.0f, -1.0f, 0.0f, 0.0f};
static const GLfloat z[] = { 0.0f, 0.0f, -1.0f, 0.0f};
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT0, GL_POSITION, x);
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT1, GL_POSITION, y);
gl_info->gl_ops.gl.p_glLightfv(GL_LIGHT2, GL_POSITION, z);
checkGLcall("Setting up reverse light directions");
gl_info->gl_ops.gl.p_glRenderMode(GL_FEEDBACK);
checkGLcall("glRenderMode(GL_FEEDBACK)");
gl_info->gl_ops.gl.p_glEvalMesh2(GL_FILL, 0, ceilf(patch->numSegs[0]), 0, ceilf(patch->numSegs[1]));
checkGLcall("glEvalMesh2");
i = gl_info->gl_ops.gl.p_glRenderMode(GL_RENDER);
checkGLcall("glRenderMode(GL_RENDER)");
i = 0;
for(j = 0; j < buffer_size; j += (3 /* num verts */ * out_vertex_size + 2 /* tri marker */)) {
if(feedbuffer[j] != GL_POLYGON_TOKEN) {
ERR("Unexpected token: %f\n", feedbuffer[j]);
continue;
}
if(feedbuffer[j + 1] != 3) {
ERR("Unexpected polygon: %f corners\n", feedbuffer[j + 1]);
continue;
}
if(patch->mem[i + 3] == 0.0f)
patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 2 + 5];
if(patch->mem[i + 4] == 0.0f)
patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 2 + 6];
if(patch->mem[i + 5] == 0.0f)
patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 2 + 7];
normalize_normal(patch->mem + i + 3);
i += d3d_out_vertex_size;
if(patch->mem[i + 3] == 0.0f)
patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 1 + 5];
if(patch->mem[i + 4] == 0.0f)
patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 1 + 6];
if(patch->mem[i + 5] == 0.0f)
patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 1 + 7];
normalize_normal(patch->mem + i + 3);
i += d3d_out_vertex_size;
if(patch->mem[i + 3] == 0.0f)
patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 0 + 5];
if(patch->mem[i + 4] == 0.0f)
patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 0 + 6];
if(patch->mem[i + 5] == 0.0f)
patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 0 + 7];
normalize_normal(patch->mem + i + 3);
i += d3d_out_vertex_size;
}
}
gl_info->gl_ops.gl.p_glDisable(GL_MAP2_VERTEX_3);
gl_info->gl_ops.gl.p_glDisable(GL_AUTO_NORMAL);
gl_info->gl_ops.gl.p_glDisable(GL_MAP2_NORMAL);
gl_info->gl_ops.gl.p_glDisable(GL_MAP2_TEXTURE_COORD_4);
checkGLcall("glDisable vertex attrib generation");
context_release(context);
HeapFree(GetProcessHeap(), 0, feedbuffer);
vtxStride = 3 * sizeof(float);
if(patch->has_normals) {
vtxStride += 3 * sizeof(float);
}
if(patch->has_texcoords) {
vtxStride += 4 * sizeof(float);
}
memset(&patch->strided, 0, sizeof(patch->strided));
patch->strided.position.format = WINED3DFMT_R32G32B32_FLOAT;
patch->strided.position.data = (BYTE *)patch->mem;
patch->strided.position.stride = vtxStride;
if (patch->has_normals)
{
patch->strided.normal.format = WINED3DFMT_R32G32B32_FLOAT;
patch->strided.normal.data = (BYTE *)patch->mem + 3 * sizeof(float) /* pos */;
patch->strided.normal.stride = vtxStride;
}
if (patch->has_texcoords)
{
patch->strided.tex_coords[0].format = WINED3DFMT_R32G32B32A32_FLOAT;
patch->strided.tex_coords[0].data = (BYTE *)patch->mem + 3 * sizeof(float) /* pos */;
if (patch->has_normals)
patch->strided.tex_coords[0].data += 3 * sizeof(float);
patch->strided.tex_coords[0].stride = vtxStride;
}
return WINED3D_OK;
}
dlls/wined3d/wined3d.spec
View file @ 149a85c2
......@@ -41,14 +41,11 @@
@ cdecl wined3d_device_color_fill(ptr ptr ptr ptr)
@ cdecl wined3d_device_create(ptr long long ptr long long ptr ptr)
@ cdecl wined3d_device_decref(ptr)
@ cdecl wined3d_device_delete_patch(ptr long)
@ cdecl wined3d_device_draw_indexed_primitive(ptr long long)
@ cdecl wined3d_device_draw_indexed_primitive_instanced(ptr long long long long)
@ cdecl wined3d_device_draw_indexed_primitive_strided(ptr long ptr long ptr long)
@ cdecl wined3d_device_draw_primitive(ptr long long)
@ cdecl wined3d_device_draw_primitive_strided(ptr long ptr)
@ cdecl wined3d_device_draw_rect_patch(ptr long ptr ptr)
@ cdecl wined3d_device_draw_tri_patch(ptr long ptr ptr)
@ cdecl wined3d_device_end_scene(ptr)
@ cdecl wined3d_device_end_stateblock(ptr ptr)
@ cdecl wined3d_device_evict_managed_resources(ptr)
......
dlls/wined3d/wined3d_private.h
View file @ 149a85c2
......@@ -1581,22 +1581,6 @@ unsigned int adapter_adjust_memory(struct wined3d_adapter *adapter, int amount)
BOOL initPixelFormatsNoGL(struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
extern void add_gl_compat_wrappers(struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
/*****************************************************************************
* High order patch management
*/
struct wined3d_rect_patch
{
UINT Handle;
float *mem;
struct wined3d_strided_data strided;
struct wined3d_rect_patch_info rect_patch_info;
float numSegs[4];
char has_normals, has_texcoords;
struct list entry;
};
HRESULT tesselate_rectpatch(struct wined3d_device *device, struct wined3d_rect_patch *patch) DECLSPEC_HIDDEN;
enum projection_types
{
proj_none = 0,
......@@ -1781,11 +1765,6 @@ struct wined3d_device
/* Context management */
struct wined3d_context **contexts;
UINT context_count;
/* High level patch management */
#define PATCHMAP_SIZE 43
#define PATCHMAP_HASHFUNC(x) ((x) % PATCHMAP_SIZE) /* Primitive and simple function */
struct list patches[PATCHMAP_SIZE];
};
void device_clear_render_targets(struct wined3d_device *device, UINT rt_count, const struct wined3d_fb_state *fb,
......
include/wine/wined3d.h
View file @ 149a85c2
......@@ -2081,7 +2081,6 @@ HRESULT __cdecl wined3d_device_create(struct wined3d *wined3d, UINT adapter_idx,
enum wined3d_device_type device_type, HWND focus_window, DWORD behaviour_flags, BYTE surface_alignment,
struct wined3d_device_parent *device_parent, struct wined3d_device **device);
ULONG __cdecl wined3d_device_decref(struct wined3d_device *device);
HRESULT __cdecl wined3d_device_delete_patch(struct wined3d_device *device, UINT handle);
HRESULT __cdecl wined3d_device_draw_indexed_primitive(struct wined3d_device *device, UINT start_idx, UINT index_count);
void __cdecl wined3d_device_draw_indexed_primitive_instanced(struct wined3d_device *device,
UINT start_idx, UINT index_count, UINT start_instance, UINT instance_count);
......@@ -2091,10 +2090,6 @@ HRESULT __cdecl wined3d_device_draw_indexed_primitive_strided(struct wined3d_dev
HRESULT __cdecl wined3d_device_draw_primitive(struct wined3d_device *device, UINT start_vertex, UINT vertex_count);
HRESULT __cdecl wined3d_device_draw_primitive_strided(struct wined3d_device *device,
UINT vertex_count, const struct wined3d_strided_data *strided_data);
HRESULT __cdecl wined3d_device_draw_rect_patch(struct wined3d_device *device, UINT handle,
const float *num_segs, const struct wined3d_rect_patch_info *rect_patch_info);
HRESULT __cdecl wined3d_device_draw_tri_patch(struct wined3d_device *device, UINT handle,
const float *num_segs, const struct wined3d_tri_patch_info *tri_patch_info);
HRESULT __cdecl wined3d_device_end_scene(struct wined3d_device *device);
HRESULT __cdecl wined3d_device_end_stateblock(struct wined3d_device *device, struct wined3d_stateblock **stateblock);
void __cdecl wined3d_device_evict_managed_resources(struct wined3d_device *device);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment