/***************************************************************************** * IDirect3DVertexBuffer7::GetVertexBufferDesc * * Returns the description of a vertex buffer * * Params: * Desc: Address to write the description to * * Returns * DDERR_INVALIDPARAMS if Desc is NULL * D3D_OK on success * *****************************************************************************/ static HRESULT WINAPI IDirect3DVertexBufferImpl_GetVertexBufferDesc(IDirect3DVertexBuffer7 *iface, D3DVERTEXBUFFERDESC *Desc) { IDirect3DVertexBufferImpl *This = (IDirect3DVertexBufferImpl *)iface; WINED3DBUFFER_DESC WDesc; HRESULT hr; TRACE("(%p)->(%p)\n", This, Desc); if(!Desc) return DDERR_INVALIDPARAMS; EnterCriticalSection(&ddraw_cs); hr = IWineD3DBuffer_GetDesc(This->wineD3DVertexBuffer, &WDesc); if(hr != D3D_OK) { ERR("(%p) IWineD3DBuffer::GetDesc failed with hr=%08x\n", This, hr); LeaveCriticalSection(&ddraw_cs); return hr; } /* Now fill the Desc structure */ Desc->dwCaps = This->Caps; Desc->dwFVF = This->fvf; Desc->dwNumVertices = WDesc.Size / get_flexible_vertex_size(This->fvf); LeaveCriticalSection(&ddraw_cs); return D3D_OK; }
HRESULT d3d_vertex_buffer_create(struct d3d_vertex_buffer **vertex_buf, struct ddraw *ddraw, D3DVERTEXBUFFERDESC *desc) { struct d3d_vertex_buffer *buffer; HRESULT hr = D3D_OK; TRACE("Vertex buffer description:\n"); TRACE(" dwSize %u\n", desc->dwSize); TRACE(" dwCaps %#x\n", desc->dwCaps); TRACE(" FVF %#x\n", desc->dwFVF); TRACE(" dwNumVertices %u\n", desc->dwNumVertices); buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*buffer)); if (!buffer) return DDERR_OUTOFMEMORY; buffer->IDirect3DVertexBuffer7_iface.lpVtbl = &d3d_vertex_buffer7_vtbl; buffer->IDirect3DVertexBuffer_iface.lpVtbl = &d3d_vertex_buffer1_vtbl; buffer->ref = 1; buffer->ddraw = ddraw; buffer->Caps = desc->dwCaps; buffer->fvf = desc->dwFVF; buffer->size = get_flexible_vertex_size(desc->dwFVF) * desc->dwNumVertices; wined3d_mutex_lock(); hr = d3d_vertex_buffer_create_wined3d_buffer(buffer, FALSE, &buffer->wineD3DVertexBuffer); if (FAILED(hr)) { WARN("Failed to create wined3d vertex buffer, hr %#x.\n", hr); if (hr == WINED3DERR_INVALIDCALL) hr = DDERR_INVALIDPARAMS; goto end; } buffer->wineD3DVertexDeclaration = ddraw_find_decl(ddraw, desc->dwFVF); if (!buffer->wineD3DVertexDeclaration) { ERR("Failed to find vertex declaration for fvf %#x.\n", desc->dwFVF); wined3d_buffer_decref(buffer->wineD3DVertexBuffer); hr = DDERR_INVALIDPARAMS; goto end; } wined3d_vertex_declaration_incref(buffer->wineD3DVertexDeclaration); end: wined3d_mutex_unlock(); if (hr == D3D_OK) *vertex_buf = buffer; else HeapFree(GetProcessHeap(), 0, buffer); return hr; }
/***************************************************************************** * IDirect3DVertexBuffer7::ProcessVertices * * Processes untransformed Vertices into a transformed or optimized vertex * buffer. It can also perform other operations, such as lighting or clipping * * Params * VertexOp: Operation(s) to perform: D3DVOP_CLIP, _EXTENTS, _LIGHT, _TRANSFORM * DestIndex: Index in the destination buffer(This), where the vertices are * placed * Count: Number of Vertices in the Source buffer to process * SrcBuffer: Source vertex buffer * SrcIndex: Index of the first vertex in the src buffer to process * D3DDevice: Device to use for transformation * Flags: 0 for default, D3DPV_DONOTCOPYDATA to prevent copying * unchaned vertices * * Returns: * D3D_OK on success * DDERR_INVALIDPARAMS If D3DVOP_TRANSFORM wasn't passed * *****************************************************************************/ static HRESULT WINAPI IDirect3DVertexBufferImpl_ProcessVertices(IDirect3DVertexBuffer7 *iface, DWORD VertexOp, DWORD DestIndex, DWORD Count, IDirect3DVertexBuffer7 *SrcBuffer, DWORD SrcIndex, IDirect3DDevice7 *D3DDevice, DWORD Flags) { IDirect3DVertexBufferImpl *This = (IDirect3DVertexBufferImpl *)iface; IDirect3DVertexBufferImpl *Src = (IDirect3DVertexBufferImpl *)SrcBuffer; IDirect3DDeviceImpl *D3D = (IDirect3DDeviceImpl *)D3DDevice; BOOL oldClip, doClip; HRESULT hr; TRACE("iface %p, vertex_op %#x, dst_idx %u, count %u, src_buffer %p, src_idx %u, device %p, flags %#x.\n", iface, VertexOp, DestIndex, Count, SrcBuffer, SrcIndex, D3DDevice, Flags); /* Vertex operations: * D3DVOP_CLIP: Clips vertices outside the viewing frustrum. Needs clipping information * in the vertex buffer (Buffer may not be created with D3DVBCAPS_DONOTCLIP) * D3DVOP_EXTENTS: Causes the screen extents to be updated when rendering the vertices * D3DVOP_LIGHT: Lights the vertices * D3DVOP_TRANSFORM: Transform the vertices. This flag is necessary * * WineD3D only transforms and clips the vertices by now, so EXTENTS and LIGHT * are not implemented. Clipping is disabled ATM, because of unsure conditions. */ if( !(VertexOp & D3DVOP_TRANSFORM) ) return DDERR_INVALIDPARAMS; EnterCriticalSection(&ddraw_cs); /* WineD3D doesn't know d3d7 vertex operation, it uses * render states instead. Set the render states according to * the vertex ops */ doClip = VertexOp & D3DVOP_CLIP ? TRUE : FALSE; wined3d_device_get_render_state(D3D->wined3d_device, WINED3DRS_CLIPPING, (DWORD *)&oldClip); if (doClip != oldClip) wined3d_device_set_render_state(D3D->wined3d_device, WINED3DRS_CLIPPING, doClip); wined3d_device_set_stream_source(D3D->wined3d_device, 0, Src->wineD3DVertexBuffer, 0, get_flexible_vertex_size(Src->fvf)); wined3d_device_set_vertex_declaration(D3D->wined3d_device, Src->wineD3DVertexDeclaration); hr = wined3d_device_process_vertices(D3D->wined3d_device, SrcIndex, DestIndex, Count, This->wineD3DVertexBuffer, NULL, Flags, This->fvf); /* Restore the states if needed */ if (doClip != oldClip) wined3d_device_set_render_state(D3D->wined3d_device, WINED3DRS_CLIPPING, oldClip); LeaveCriticalSection(&ddraw_cs); return hr; }
/***************************************************************************** * IDirect3DVertexBuffer7::ProcessVertices * * Processes untransformed Vertices into a transformed or optimized vertex * buffer. It can also perform other operations, such as lighting or clipping * * Params * VertexOp: Operation(s) to perform: D3DVOP_CLIP, _EXTENTS, _LIGHT, _TRANSFORM * DestIndex: Index in the destination buffer(This), where the vertices are * placed * Count: Number of Vertices in the Source buffer to process * SrcBuffer: Source vertex buffer * SrcIndex: Index of the first vertex in the src buffer to process * D3DDevice: Device to use for transformation * Flags: 0 for default, D3DPV_DONOTCOPYDATA to prevent copying * unchaned vertices * * Returns: * D3D_OK on success * DDERR_INVALIDPARAMS If D3DVOP_TRANSFORM wasn't passed * *****************************************************************************/ static HRESULT WINAPI d3d_vertex_buffer7_ProcessVertices(IDirect3DVertexBuffer7 *iface, DWORD vertex_op, DWORD dst_idx, DWORD count, IDirect3DVertexBuffer7 *src_buffer, DWORD src_idx, IDirect3DDevice7 *device, DWORD flags) { struct d3d_vertex_buffer *dst_buffer_impl = impl_from_IDirect3DVertexBuffer7(iface); struct d3d_vertex_buffer *src_buffer_impl = unsafe_impl_from_IDirect3DVertexBuffer7(src_buffer); struct d3d_device *device_impl = unsafe_impl_from_IDirect3DDevice7(device); BOOL oldClip, doClip; HRESULT hr; TRACE("iface %p, vertex_op %#x, dst_idx %u, count %u, src_buffer %p, src_idx %u, device %p, flags %#x.\n", iface, vertex_op, dst_idx, count, src_buffer, src_idx, device, flags); /* Vertex operations: * D3DVOP_CLIP: Clips vertices outside the viewing frustrum. Needs clipping information * in the vertex buffer (Buffer may not be created with D3DVBCAPS_DONOTCLIP) * D3DVOP_EXTENTS: Causes the screen extents to be updated when rendering the vertices * D3DVOP_LIGHT: Lights the vertices * D3DVOP_TRANSFORM: Transform the vertices. This flag is necessary * * WineD3D only transforms and clips the vertices by now, so EXTENTS and LIGHT * are not implemented. Clipping is disabled ATM, because of unsure conditions. */ if (!(vertex_op & D3DVOP_TRANSFORM)) return DDERR_INVALIDPARAMS; wined3d_mutex_lock(); /* WineD3D doesn't know d3d7 vertex operation, it uses * render states instead. Set the render states according to * the vertex ops */ doClip = !!(vertex_op & D3DVOP_CLIP); oldClip = wined3d_device_get_render_state(device_impl->wined3d_device, WINED3D_RS_CLIPPING); if (doClip != oldClip) wined3d_device_set_render_state(device_impl->wined3d_device, WINED3D_RS_CLIPPING, doClip); wined3d_device_set_stream_source(device_impl->wined3d_device, 0, src_buffer_impl->wineD3DVertexBuffer, 0, get_flexible_vertex_size(src_buffer_impl->fvf)); wined3d_device_set_vertex_declaration(device_impl->wined3d_device, src_buffer_impl->wineD3DVertexDeclaration); hr = wined3d_device_process_vertices(device_impl->wined3d_device, src_idx, dst_idx, count, dst_buffer_impl->wineD3DVertexBuffer, NULL, flags, dst_buffer_impl->fvf); /* Restore the states if needed */ if (doClip != oldClip) wined3d_device_set_render_state(device_impl->wined3d_device, WINED3D_RS_CLIPPING, oldClip); wined3d_mutex_unlock(); return hr; }
HRESULT d3d_vertex_buffer_init(IDirect3DVertexBufferImpl *buffer, IDirectDrawImpl *ddraw, D3DVERTEXBUFFERDESC *desc) { DWORD usage; HRESULT hr; buffer->lpVtbl = &d3d_vertex_buffer7_vtbl; buffer->IDirect3DVertexBuffer_vtbl = &d3d_vertex_buffer1_vtbl; buffer->ref = 1; buffer->ddraw = ddraw; buffer->Caps = desc->dwCaps; buffer->fvf = desc->dwFVF; usage = desc->dwCaps & D3DVBCAPS_WRITEONLY ? WINED3DUSAGE_WRITEONLY : 0; usage |= WINED3DUSAGE_STATICDECL; EnterCriticalSection(&ddraw_cs); hr = IWineD3DDevice_CreateVertexBuffer(ddraw->wineD3DDevice, get_flexible_vertex_size(desc->dwFVF) * desc->dwNumVertices, usage, desc->dwCaps & D3DVBCAPS_SYSTEMMEMORY ? WINED3DPOOL_SYSTEMMEM : WINED3DPOOL_DEFAULT, buffer, &ddraw_null_wined3d_parent_ops, &buffer->wineD3DVertexBuffer); if (FAILED(hr)) { WARN("Failed to create wined3d vertex buffer, hr %#x.\n", hr); LeaveCriticalSection(&ddraw_cs); if (hr == WINED3DERR_INVALIDCALL) return DDERR_INVALIDPARAMS; else return hr; } buffer->wineD3DVertexDeclaration = ddraw_find_decl(ddraw, desc->dwFVF); if (!buffer->wineD3DVertexDeclaration) { ERR("Failed to find vertex declaration for fvf %#x.\n", desc->dwFVF); IWineD3DBuffer_Release(buffer->wineD3DVertexBuffer); LeaveCriticalSection(&ddraw_cs); return DDERR_INVALIDPARAMS; } IWineD3DVertexDeclaration_AddRef(buffer->wineD3DVertexDeclaration); LeaveCriticalSection(&ddraw_cs); return D3D_OK; }
/***************************************************************************** * IDirect3DVertexBuffer7::GetVertexBufferDesc * * Returns the description of a vertex buffer * * Params: * Desc: Address to write the description to * * Returns * DDERR_INVALIDPARAMS if Desc is NULL * D3D_OK on success * *****************************************************************************/ static HRESULT WINAPI d3d_vertex_buffer7_GetVertexBufferDesc(IDirect3DVertexBuffer7 *iface, D3DVERTEXBUFFERDESC *desc) { struct d3d_vertex_buffer *buffer = impl_from_IDirect3DVertexBuffer7(iface); struct wined3d_resource_desc wined3d_desc; struct wined3d_resource *wined3d_resource; TRACE("iface %p, desc %p.\n", iface, desc); if (!desc) return DDERR_INVALIDPARAMS; wined3d_mutex_lock(); wined3d_resource = wined3d_buffer_get_resource(buffer->wineD3DVertexBuffer); wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); wined3d_mutex_unlock(); /* Now fill the desc structure */ desc->dwCaps = buffer->Caps; desc->dwFVF = buffer->fvf; desc->dwNumVertices = wined3d_desc.size / get_flexible_vertex_size(buffer->fvf); return D3D_OK; }
/***************************************************************************** * IDirect3DVertexBuffer7::GetVertexBufferDesc * * Returns the description of a vertex buffer * * Params: * Desc: Address to write the description to * * Returns * DDERR_INVALIDPARAMS if Desc is NULL * D3D_OK on success * *****************************************************************************/ static HRESULT WINAPI IDirect3DVertexBufferImpl_GetVertexBufferDesc(IDirect3DVertexBuffer7 *iface, D3DVERTEXBUFFERDESC *Desc) { IDirect3DVertexBufferImpl *This = (IDirect3DVertexBufferImpl *)iface; WINED3DBUFFER_DESC WDesc; TRACE("iface %p, desc %p.\n", iface, Desc); if(!Desc) return DDERR_INVALIDPARAMS; EnterCriticalSection(&ddraw_cs); IWineD3DBuffer_GetDesc(This->wineD3DVertexBuffer, &WDesc); LeaveCriticalSection(&ddraw_cs); /* Now fill the Desc structure */ Desc->dwCaps = This->Caps; Desc->dwFVF = This->fvf; Desc->dwNumVertices = WDesc.Size / get_flexible_vertex_size(This->fvf); return D3D_OK; }
/***************************************************************************** * IDirect3DVertexBuffer7::GetVertexBufferDesc * * Returns the description of a vertex buffer * * Params: * Desc: Address to write the description to * * Returns * DDERR_INVALIDPARAMS if Desc is NULL * D3D_OK on success * *****************************************************************************/ static HRESULT WINAPI IDirect3DVertexBufferImpl_GetVertexBufferDesc(IDirect3DVertexBuffer7 *iface, D3DVERTEXBUFFERDESC *Desc) { IDirect3DVertexBufferImpl *This = (IDirect3DVertexBufferImpl *)iface; struct wined3d_resource_desc wined3d_desc; struct wined3d_resource *wined3d_resource; TRACE("iface %p, desc %p.\n", iface, Desc); if(!Desc) return DDERR_INVALIDPARAMS; EnterCriticalSection(&ddraw_cs); wined3d_resource = wined3d_buffer_get_resource(This->wineD3DVertexBuffer); wined3d_resource_get_desc(wined3d_resource, &wined3d_desc); LeaveCriticalSection(&ddraw_cs); /* Now fill the Desc structure */ Desc->dwCaps = This->Caps; Desc->dwFVF = This->fvf; Desc->dwNumVertices = wined3d_desc.size / get_flexible_vertex_size(This->fvf); return D3D_OK; }
/***************************************************************************** * IDirect3DVertexBuffer7::ProcessVertices * * Processes untransformed Vertices into a transformed or optimized vertex * buffer. It can also perform other operations, such as lighting or clipping * * Params * VertexOp: Operation(s) to perform: D3DVOP_CLIP, _EXTENTS, _LIGHT, _TRANSFORM * DestIndex: Index in the destination buffer(This), where the vertices are * placed * Count: Number of Vertices in the Source buffer to process * SrcBuffer: Source vertex buffer * SrcIndex: Index of the first vertex in the src buffer to process * D3DDevice: Device to use for transformation * Flags: 0 for default, D3DPV_DONOTCOPYDATA to prevent copying * unchaned vertices * * Returns: * D3D_OK on success * DDERR_INVALIDPARAMS If D3DVOP_TRANSFORM wasn't passed * *****************************************************************************/ static HRESULT WINAPI IDirect3DVertexBufferImpl_ProcessVertices(IDirect3DVertexBuffer7 *iface, DWORD VertexOp, DWORD DestIndex, DWORD Count, IDirect3DVertexBuffer7 *SrcBuffer, DWORD SrcIndex, IDirect3DDevice7 *D3DDevice, DWORD Flags) { ICOM_THIS_FROM(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, iface); IDirect3DVertexBufferImpl *Src = ICOM_OBJECT(IDirect3DVertexBufferImpl, IDirect3DVertexBuffer7, SrcBuffer); IDirect3DDeviceImpl *D3D = ICOM_OBJECT(IDirect3DDeviceImpl, IDirect3DDevice7, D3DDevice); BOOL oldClip, doClip; HRESULT hr; WINED3DVERTEXBUFFER_DESC Desc; TRACE("(%p)->(%08x,%d,%d,%p,%d,%p,%08x)\n", This, VertexOp, DestIndex, Count, Src, SrcIndex, D3D, Flags); /* Vertex operations: * D3DVOP_CLIP: Clips vertices outside the viewing frustrum. Needs clipping information * in the vertex buffer (Buffer may not be created with D3DVBCAPS_DONOTCLIP) * D3DVOP_EXTENTS: Causes the screen extents to be updated when rendering the vertices * D3DVOP_LIGHT: Lights the vertices * D3DVOP_TRANSFORM: Transform the vertices. This flag is necessary * * WineD3D only transforms and clips the vertices by now, so EXTENTS and LIGHT * are not implemented. Clipping is disabled ATM, because of unsure conditions. */ if( !(VertexOp & D3DVOP_TRANSFORM) ) return DDERR_INVALIDPARAMS; EnterCriticalSection(&ddraw_cs); /* WineD3D doesn't know d3d7 vertex operation, it uses * render states instead. Set the render states according to * the vertex ops */ doClip = VertexOp & D3DVOP_CLIP ? TRUE : FALSE; IWineD3DDevice_GetRenderState(D3D->wineD3DDevice, WINED3DRS_CLIPPING, (DWORD *) &oldClip); if(doClip != oldClip) { IWineD3DDevice_SetRenderState(D3D->wineD3DDevice, WINED3DRS_CLIPPING, doClip); } IWineD3DVertexBuffer_GetDesc(Src->wineD3DVertexBuffer, &Desc); IWineD3DDevice_SetStreamSource(D3D->wineD3DDevice, 0, /* Stream No */ Src->wineD3DVertexBuffer, 0, /* Offset */ get_flexible_vertex_size(Desc.FVF)); IWineD3DDevice_SetVertexDeclaration(D3D->wineD3DDevice, Src->wineD3DVertexDeclaration); hr = IWineD3DDevice_ProcessVertices(D3D->wineD3DDevice, SrcIndex, DestIndex, Count, This->wineD3DVertexBuffer, NULL /* Output vdecl */, Flags); /* Restore the states if needed */ if(doClip != oldClip) IWineD3DDevice_SetRenderState(D3D->wineD3DDevice, WINED3DRS_CLIPPING, oldClip); LeaveCriticalSection(&ddraw_cs); return hr; }
HRESULT d3d_vertex_buffer_create(IDirect3DVertexBufferImpl **vertex_buf, struct ddraw *ddraw, D3DVERTEXBUFFERDESC *desc) { IDirect3DVertexBufferImpl *buffer; DWORD usage; HRESULT hr = D3D_OK; TRACE("Vertex buffer description:\n"); TRACE(" dwSize %u\n", desc->dwSize); TRACE(" dwCaps %#x\n", desc->dwCaps); TRACE(" FVF %#x\n", desc->dwFVF); TRACE(" dwNumVertices %u\n", desc->dwNumVertices); buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*buffer)); if (!buffer) return DDERR_OUTOFMEMORY; buffer->IDirect3DVertexBuffer7_iface.lpVtbl = &d3d_vertex_buffer7_vtbl; buffer->IDirect3DVertexBuffer_iface.lpVtbl = &d3d_vertex_buffer1_vtbl; buffer->ref = 1; buffer->ddraw = ddraw; buffer->Caps = desc->dwCaps; buffer->fvf = desc->dwFVF; usage = desc->dwCaps & D3DVBCAPS_WRITEONLY ? WINED3DUSAGE_WRITEONLY : 0; usage |= WINED3DUSAGE_STATICDECL; wined3d_mutex_lock(); hr = wined3d_buffer_create_vb(ddraw->wined3d_device, get_flexible_vertex_size(desc->dwFVF) * desc->dwNumVertices, usage, desc->dwCaps & D3DVBCAPS_SYSTEMMEMORY ? WINED3D_POOL_SYSTEM_MEM : WINED3D_POOL_DEFAULT, buffer, &ddraw_null_wined3d_parent_ops, &buffer->wineD3DVertexBuffer); if (FAILED(hr)) { WARN("Failed to create wined3d vertex buffer, hr %#x.\n", hr); if (hr == WINED3DERR_INVALIDCALL) hr = DDERR_INVALIDPARAMS; goto end; } buffer->wineD3DVertexDeclaration = ddraw_find_decl(ddraw, desc->dwFVF); if (!buffer->wineD3DVertexDeclaration) { ERR("Failed to find vertex declaration for fvf %#x.\n", desc->dwFVF); wined3d_buffer_decref(buffer->wineD3DVertexBuffer); hr = DDERR_INVALIDPARAMS; goto end; } wined3d_vertex_declaration_incref(buffer->wineD3DVertexDeclaration); end: wined3d_mutex_unlock(); if (hr == D3D_OK) *vertex_buf = buffer; else HeapFree(GetProcessHeap(), 0, buffer); return hr; }