ddraw_private.h File Reference

#include <assert.h>
#include <limits.h>
#include "wine/debug.h"
#include "wine/heap.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "d3d.h"
#include "ddraw.h"
#include "wine/list.h"
#include "wine/wined3d.h"

Include dependency graph for ddraw_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	FvfToDecl
struct	ddraw
struct	ddraw_surface
struct	ddraw_texture
struct	ddraw_handle_entry
struct	ddraw_handle_table
struct	d3d_device
struct	ddraw_clipper
struct	ddraw_palette
struct	object_creation_info
struct	d3d_light
struct	d3d_material
struct	d3d_viewport
struct	d3d_execute_buffer
struct	d3d_vertex_buffer
struct	flag_info
struct	member_info

Macros
#define	COBJMACROS
#define	NONAMELESSSTRUCT
#define	NONAMELESSUNION
#define	DDRAW_INITIALIZED   0x00000001
#define	DDRAW_D3D_INITIALIZED   0x00000002
#define	DDRAW_RESTORE_MODE   0x00000004
#define	DDRAW_NO3D   0x00000008
#define	DDRAW_SCL_DDRAW1   0x00000010
#define	DDRAW_SCL_RECURSIVE   0x00000020
#define	DDRAW_GDI_FLIP   0x00000040
#define	DDRAW_STRIDE_ALIGNMENT   8
#define	DDRAW_WINED3D_FLAGS
#define	DDRAW_WINDOW_CLASS_NAME   "DirectDrawDeviceWnd"
#define	MAX_COMPLEX_ATTACHED   6
#define	DDRAW_INVALID_HANDLE   ~0U
#define	GET_TEXCOUNT_FROM_FVF(d3dvtVertexType)    (((d3dvtVertexType) & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT)
#define	GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_num)    (((((d3dvtVertexType) >> (16 + (2 * (tex_num)))) + 1) & 0x03) + 1)
#define	FE(x)   { x, #x }
#define	ME(x, f, e)   { x, #x, (void (*)(const void *))(f), offsetof(STRUCT, e) }
#define	DD_STRUCT_COPY_BYSIZE_(to, from, to_size, from_size)
#define	DD_STRUCT_COPY_BYSIZE(to, from)   DD_STRUCT_COPY_BYSIZE_(to,from,(to)->dwSize,(from)->dwSize)

Enumerations
enum	ddraw_device_state { DDRAW_DEVICE_STATE_OK , DDRAW_DEVICE_STATE_LOST , DDRAW_DEVICE_STATE_NOT_RESTORED }
enum	ddraw_handle_type {   DDRAW_HANDLE_FREE , DDRAW_HANDLE_MATERIAL , DDRAW_HANDLE_MATRIX , DDRAW_HANDLE_STATEBLOCK ,   DDRAW_HANDLE_SURFACE }

Functions
HRESULT	ddraw_init (struct ddraw *ddraw, DWORD flags, enum wined3d_device_type device_type) DECLSPEC_HIDDEN
void	ddraw_d3dcaps1_from_7 (D3DDEVICEDESC *caps1, D3DDEVICEDESC7 *caps7) DECLSPEC_HIDDEN
HRESULT	ddraw_get_d3dcaps (const struct ddraw *ddraw, D3DDEVICEDESC7 *caps) DECLSPEC_HIDDEN
void	ddraw_update_lost_surfaces (struct ddraw *ddraw) DECLSPEC_HIDDEN
static void	ddraw_set_swapchain_window (struct ddraw *ddraw, HWND window)
void	DDRAW_Convert_DDSCAPS_1_To_2 (const DDSCAPS *pIn, DDSCAPS2 *pOut) DECLSPEC_HIDDEN
void	DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1 (const DDDEVICEIDENTIFIER2 *pIn, DDDEVICEIDENTIFIER *pOut) DECLSPEC_HIDDEN
struct wined3d_vertex_declaration *	ddraw_find_decl (struct ddraw *ddraw, DWORD fvf) DECLSPEC_HIDDEN
HRESULT	ddraw_surface_create (struct ddraw *ddraw, const DDSURFACEDESC2 *surface_desc, struct ddraw_surface **surface, IUnknown *outer_unknown, unsigned int version) DECLSPEC_HIDDEN
struct wined3d_rendertarget_view *	ddraw_surface_get_rendertarget_view (struct ddraw_surface *surface) DECLSPEC_HIDDEN
void	ddraw_surface_init (struct ddraw_surface *surface, struct ddraw *ddraw, struct wined3d_texture *wined3d_texture, unsigned int sub_resource_idx, const struct wined3d_parent_ops **parent_ops) DECLSPEC_HIDDEN
HRESULT	ddraw_surface_update_frontbuffer (struct ddraw_surface *surface, const RECT *rect, BOOL read) DECLSPEC_HIDDEN
static struct ddraw_surface *	impl_from_IDirect3DTexture (IDirect3DTexture *iface)
static struct ddraw_surface *	impl_from_IDirect3DTexture2 (IDirect3DTexture2 *iface)
static struct ddraw_surface *	impl_from_IDirectDrawSurface (IDirectDrawSurface *iface)
static struct ddraw_surface *	impl_from_IDirectDrawSurface2 (IDirectDrawSurface2 *iface)
static struct ddraw_surface *	impl_from_IDirectDrawSurface3 (IDirectDrawSurface3 *iface)
static struct ddraw_surface *	impl_from_IDirectDrawSurface4 (IDirectDrawSurface4 *iface)
static struct ddraw_surface *	impl_from_IDirectDrawSurface7 (IDirectDrawSurface7 *iface)
struct ddraw_surface *	unsafe_impl_from_IDirectDrawSurface (IDirectDrawSurface *iface) DECLSPEC_HIDDEN
struct ddraw_surface *	unsafe_impl_from_IDirectDrawSurface4 (IDirectDrawSurface4 *iface) DECLSPEC_HIDDEN
struct ddraw_surface *	unsafe_impl_from_IDirectDrawSurface7 (IDirectDrawSurface7 *iface) DECLSPEC_HIDDEN
struct ddraw_surface *	unsafe_impl_from_IDirect3DTexture (IDirect3DTexture *iface) DECLSPEC_HIDDEN
struct ddraw_surface *	unsafe_impl_from_IDirect3DTexture2 (IDirect3DTexture2 *iface) DECLSPEC_HIDDEN
BOOL	ddraw_handle_table_init (struct ddraw_handle_table *t, UINT initial_size) DECLSPEC_HIDDEN
void	ddraw_handle_table_destroy (struct ddraw_handle_table *t) DECLSPEC_HIDDEN
DWORD	ddraw_allocate_handle (struct ddraw_handle_table *t, void *object, enum ddraw_handle_type type) DECLSPEC_HIDDEN
void *	ddraw_free_handle (struct ddraw_handle_table *t, DWORD handle, enum ddraw_handle_type type) DECLSPEC_HIDDEN
void *	ddraw_get_object (struct ddraw_handle_table *t, DWORD handle, enum ddraw_handle_type type) DECLSPEC_HIDDEN
HRESULT	d3d_device_create (struct ddraw *ddraw, const GUID *guid, struct ddraw_surface *target, IUnknown *rt_iface, UINT version, struct d3d_device **device, IUnknown *outer_unknown) DECLSPEC_HIDDEN
enum wined3d_depth_buffer_type	d3d_device_update_depth_stencil (struct d3d_device *device) DECLSPEC_HIDDEN
static struct d3d_device *	impl_from_IDirect3DDevice (IDirect3DDevice *iface)
static struct d3d_device *	impl_from_IDirect3DDevice2 (IDirect3DDevice2 *iface)
static struct d3d_device *	impl_from_IDirect3DDevice3 (IDirect3DDevice3 *iface)
static struct d3d_device *	impl_from_IDirect3DDevice7 (IDirect3DDevice7 *iface)
struct d3d_device *	unsafe_impl_from_IDirect3DDevice (IDirect3DDevice *iface) DECLSPEC_HIDDEN
struct d3d_device *	unsafe_impl_from_IDirect3DDevice2 (IDirect3DDevice2 *iface) DECLSPEC_HIDDEN
struct d3d_device *	unsafe_impl_from_IDirect3DDevice3 (IDirect3DDevice3 *iface) DECLSPEC_HIDDEN
struct d3d_device *	unsafe_impl_from_IDirect3DDevice7 (IDirect3DDevice7 *iface) DECLSPEC_HIDDEN
HRESULT	ddraw_clipper_init (struct ddraw_clipper *clipper) DECLSPEC_HIDDEN
struct ddraw_clipper *	unsafe_impl_from_IDirectDrawClipper (IDirectDrawClipper *iface) DECLSPEC_HIDDEN
static struct ddraw_palette *	impl_from_IDirectDrawPalette (IDirectDrawPalette *iface)
struct ddraw_palette *	unsafe_impl_from_IDirectDrawPalette (IDirectDrawPalette *iface) DECLSPEC_HIDDEN
HRESULT	ddraw_palette_init (struct ddraw_palette *palette, struct ddraw *ddraw, DWORD flags, PALETTEENTRY *entries) DECLSPEC_HIDDEN
void	light_activate (struct d3d_light *light) DECLSPEC_HIDDEN
void	light_deactivate (struct d3d_light *light) DECLSPEC_HIDDEN
void	d3d_light_init (struct d3d_light *light, struct ddraw *ddraw) DECLSPEC_HIDDEN
struct d3d_light *	unsafe_impl_from_IDirect3DLight (IDirect3DLight *iface) DECLSPEC_HIDDEN
void	material_activate (struct d3d_material *material) DECLSPEC_HIDDEN
struct d3d_material *	d3d_material_create (struct ddraw *ddraw) DECLSPEC_HIDDEN
struct d3d_viewport *	unsafe_impl_from_IDirect3DViewport3 (IDirect3DViewport3 *iface) DECLSPEC_HIDDEN
struct d3d_viewport *	unsafe_impl_from_IDirect3DViewport2 (IDirect3DViewport2 *iface) DECLSPEC_HIDDEN
struct d3d_viewport *	unsafe_impl_from_IDirect3DViewport (IDirect3DViewport *iface) DECLSPEC_HIDDEN
void	viewport_activate (struct d3d_viewport *viewport, BOOL ignore_lights) DECLSPEC_HIDDEN
void	d3d_viewport_init (struct d3d_viewport *viewport, struct ddraw *ddraw) DECLSPEC_HIDDEN
HRESULT	d3d_execute_buffer_init (struct d3d_execute_buffer *execute_buffer, struct d3d_device *device, D3DEXECUTEBUFFERDESC *desc) DECLSPEC_HIDDEN
struct d3d_execute_buffer *	unsafe_impl_from_IDirect3DExecuteBuffer (IDirect3DExecuteBuffer *iface) DECLSPEC_HIDDEN
HRESULT	d3d_execute_buffer_execute (struct d3d_execute_buffer *execute_buffer, struct d3d_device *device, struct d3d_viewport *viewport) DECLSPEC_HIDDEN
HRESULT	d3d_vertex_buffer_create (struct d3d_vertex_buffer **buffer, struct ddraw *ddraw, D3DVERTEXBUFFERDESC *desc) DECLSPEC_HIDDEN
struct d3d_vertex_buffer *	unsafe_impl_from_IDirect3DVertexBuffer (IDirect3DVertexBuffer *iface) DECLSPEC_HIDDEN
struct d3d_vertex_buffer *	unsafe_impl_from_IDirect3DVertexBuffer7 (IDirect3DVertexBuffer7 *iface) DECLSPEC_HIDDEN
void	ddrawformat_from_wined3dformat (DDPIXELFORMAT *ddraw_format, enum wined3d_format_id wined3d_format) DECLSPEC_HIDDEN
BOOL	wined3d_colour_from_ddraw_colour (const DDPIXELFORMAT *pf, const struct ddraw_palette *palette, DWORD colour, struct wined3d_color *wined3d_colour) DECLSPEC_HIDDEN
enum wined3d_format_id	wined3dformat_from_ddrawformat (const DDPIXELFORMAT *format) DECLSPEC_HIDDEN
unsigned int	wined3dmapflags_from_ddrawmapflags (unsigned int flags) DECLSPEC_HIDDEN
void	DDRAW_dump_surface_desc (const DDSURFACEDESC2 *lpddsd) DECLSPEC_HIDDEN
void	dump_D3DMATRIX (const D3DMATRIX *mat) DECLSPEC_HIDDEN
void	DDRAW_dump_DDCAPS (const DDCAPS *lpcaps) DECLSPEC_HIDDEN
DWORD	get_flexible_vertex_size (DWORD d3dvtVertexType) DECLSPEC_HIDDEN
void	DDRAW_dump_DDSCAPS2 (const DDSCAPS2 *in) DECLSPEC_HIDDEN
void	DDRAW_dump_cooperativelevel (DWORD cooplevel) DECLSPEC_HIDDEN
void	DDSD_to_DDSD2 (const DDSURFACEDESC *in, DDSURFACEDESC2 *out) DECLSPEC_HIDDEN
void	DDSD2_to_DDSD (const DDSURFACEDESC2 *in, DDSURFACEDESC *out) DECLSPEC_HIDDEN
void	multiply_matrix (D3DMATRIX *dst, const D3DMATRIX *src1, const D3DMATRIX *src2) DECLSPEC_HIDDEN
static BOOL	format_is_compressed (const DDPIXELFORMAT *format)
static BOOL	format_is_paletteindexed (const DDPIXELFORMAT *fmt)
HRESULT	hr_ddraw_from_wined3d (HRESULT hr) DECLSPEC_HIDDEN

Variables
const struct wined3d_parent_ops ddraw_null_wined3d_parent_ops	DECLSPEC_HIDDEN

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file ddraw_private.h.

DD_STRUCT_COPY_BYSIZE

#define DD_STRUCT_COPY_BYSIZE	(		to,
			from
	)		DD_STRUCT_COPY_BYSIZE_(to,from,(to)->dwSize,(from)->dwSize)

Definition at line 647 of file ddraw_private.h.

DD_STRUCT_COPY_BYSIZE_

#define DD_STRUCT_COPY_BYSIZE_	(		to,
			from,
			to_size,
			from_size
	)

Value:

    do {                                                          \
        DWORD __size = (to)->dwSize;                              \
        DWORD __resetsize = min(to_size, sizeof(*to));            \
        DWORD __copysize = min(__resetsize, from_size);           \
        assert(to != from);                                       \
        memcpy(to, from, __copysize);                             \
        memset((char*)(to) + __copysize, 0, __resetsize - __copysize); \
        (to)->dwSize = __size; /* restore size */                 \
    } while (0)

Definition at line 636 of file ddraw_private.h.

DDRAW_D3D_INITIALIZED

#define DDRAW_D3D_INITIALIZED   0x00000002

Definition at line 55 of file ddraw_private.h.

DDRAW_GDI_FLIP

#define DDRAW_GDI_FLIP   0x00000040

Definition at line 60 of file ddraw_private.h.

DDRAW_INITIALIZED

#define DDRAW_INITIALIZED   0x00000001

Definition at line 54 of file ddraw_private.h.

DDRAW_INVALID_HANDLE

#define DDRAW_INVALID_HANDLE   ~0U

Definition at line 265 of file ddraw_private.h.

DDRAW_NO3D

#define DDRAW_NO3D   0x00000008

Definition at line 57 of file ddraw_private.h.

DDRAW_RESTORE_MODE

#define DDRAW_RESTORE_MODE   0x00000004

Definition at line 56 of file ddraw_private.h.

DDRAW_SCL_DDRAW1

#define DDRAW_SCL_DDRAW1   0x00000010

Definition at line 58 of file ddraw_private.h.

DDRAW_SCL_RECURSIVE

#define DDRAW_SCL_RECURSIVE   0x00000020

Definition at line 59 of file ddraw_private.h.

DDRAW_STRIDE_ALIGNMENT

#define DDRAW_STRIDE_ALIGNMENT   8

Definition at line 62 of file ddraw_private.h.

DDRAW_WINDOW_CLASS_NAME

#define DDRAW_WINDOW_CLASS_NAME   "DirectDrawDeviceWnd"

Definition at line 128 of file ddraw_private.h.

DDRAW_WINED3D_FLAGS

#define DDRAW_WINED3D_FLAGS

Value:

        (WINED3D_LEGACY_DEPTH_BIAS | WINED3D_VIDMEM_ACCOUNTING \
        | WINED3D_RESTORE_MODE_ON_ACTIVATE | WINED3D_FOCUS_MESSAGES | WINED3D_PIXEL_CENTER_INTEGER \
        | WINED3D_LEGACY_UNBOUND_RESOURCE_COLOR | WINED3D_NO_PRIMITIVE_RESTART \
        | WINED3D_LEGACY_CUBEMAP_FILTERING | WINED3D_LIMIT_VIEWPORT)

Definition at line 64 of file ddraw_private.h.

FE

#define FE

(

x

)

{ x, #x }

Definition at line 623 of file ddraw_private.h.

GET_TEXCOORD_SIZE_FROM_FVF

#define GET_TEXCOORD_SIZE_FROM_FVF	(		d3dvtVertexType,
			tex_num
	)		(((((d3dvtVertexType) >> (16 + (2 * (tex_num)))) + 1) & 0x03) + 1)

Definition at line 582 of file ddraw_private.h.

GET_TEXCOUNT_FROM_FVF

#define GET_TEXCOUNT_FROM_FVF

(

d3dvtVertexType

)

(((d3dvtVertexType) & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT)

Definition at line 579 of file ddraw_private.h.

MAX_COMPLEX_ATTACHED

#define MAX_COMPLEX_ATTACHED   6

Definition at line 183 of file ddraw_private.h.

ME

#define ME	(		x,
			f,
			e
	)		{ x, #x, (void (*)(const void *))(f), offsetof(STRUCT, e) }

Definition at line 634 of file ddraw_private.h.

NONAMELESSSTRUCT

#define NONAMELESSSTRUCT

Definition at line 25 of file ddraw_private.h.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 26 of file ddraw_private.h.

Enumeration Type Documentation

ddraw_device_state

enum ddraw_device_state

Enumerator
DDRAW_DEVICE_STATE_OK
DDRAW_DEVICE_STATE_LOST
DDRAW_DEVICE_STATE_NOT_RESTORED

Definition at line 69 of file ddraw_private.h.

{
    DDRAW_DEVICE_STATE_OK,
    DDRAW_DEVICE_STATE_LOST,
    DDRAW_DEVICE_STATE_NOT_RESTORED,
};

ddraw_handle_type

enum ddraw_handle_type

Enumerator
DDRAW_HANDLE_FREE
DDRAW_HANDLE_MATERIAL
DDRAW_HANDLE_MATRIX
DDRAW_HANDLE_STATEBLOCK
DDRAW_HANDLE_SURFACE

Definition at line 267 of file ddraw_private.h.

{
    DDRAW_HANDLE_FREE,
    DDRAW_HANDLE_MATERIAL,
    DDRAW_HANDLE_MATRIX,
    DDRAW_HANDLE_STATEBLOCK,
    DDRAW_HANDLE_SURFACE,
};

Function Documentation

d3d_device_create()

HRESULT d3d_device_create	(	struct ddraw *	ddraw,
		const GUID *	guid,
		struct ddraw_surface *	target,
		IUnknown *	rt_iface,
		UINT	version,
		struct d3d_device **	device,
		IUnknown *	outer_unknown
	)

Definition at line 6980 of file device.c.

{
    struct d3d_device *object;
    BOOL hw = TRUE;
    HRESULT hr;
 
    TRACE("ddraw %p, guid %s, target %p, version %u, device %p, outer_unknown %p.\n",
            ddraw, debugstr_guid(guid), target, version, device, outer_unknown);
 
    if (IsEqualGUID(guid, &IID_IDirect3DRGBDevice))
        hw = FALSE;
 
    if (!(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
            || (target->surface_desc.ddsCaps.dwCaps & DDSCAPS_ZBUFFER))
    {
        WARN("Surface %p is not a render target.\n", target);
        return DDERR_INVALIDCAPS;
    }
 
    if (!validate_surface_palette(target))
    {
        WARN("Surface %p has an indexed pixel format, but no palette.\n", target);
        return DDERR_NOPALETTEATTACHED;
    }
 
    if (hw && !(target->surface_desc.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
    {
        WARN("Surface %p is not in video memory.\n", target);
        return D3DERR_SURFACENOTINVIDMEM;
    }
 
    if (ddraw->flags & DDRAW_NO3D)
    {
        ERR_(winediag)("The application wants to create a Direct3D device, "
                "but the current DirectDrawRenderer does not support this.\n");
 
        return DDERR_NO3D;
    }
 
    if (ddraw->d3ddevice)
    {
        FIXME("Only one Direct3D device per DirectDraw object supported.\n");
        return DDERR_INVALIDPARAMS;
    }
 
    if (!(object = heap_alloc_zero(sizeof(*object))))
    {
        ERR("Failed to allocate device memory.\n");
        return DDERR_OUTOFMEMORY;
    }
 
    if (FAILED(hr = d3d_device_init(object, ddraw, hw, target, rt_iface, version, outer_unknown)))
    {
        WARN("Failed to initialize device, hr %#x.\n", hr);
        heap_free(object);
        return hr;
    }
 
    TRACE("Created device %p.\n", object);
    *device = object;
 
    return D3D_OK;
}

Referenced by d3d2_CreateDevice(), d3d3_CreateDevice(), d3d7_CreateDevice(), and ddraw_surface7_QueryInterface().

d3d_device_update_depth_stencil()

enum wined3d_depth_buffer_type d3d_device_update_depth_stencil

(

struct d3d_device *

device

)

Definition at line 6878 of file device.c.

{
    IDirectDrawSurface7 *depthStencil = NULL;
    IDirectDrawSurface7 *render_target;
    static DDSCAPS2 depthcaps = { DDSCAPS_ZBUFFER, 0, 0, {0} };
    struct ddraw_surface *dsi;
 
    if (device->rt_iface && SUCCEEDED(IUnknown_QueryInterface(device->rt_iface,
            &IID_IDirectDrawSurface7, (void **)&render_target)))
    {
        IDirectDrawSurface7_GetAttachedSurface(render_target, &depthcaps, &depthStencil);
        IDirectDrawSurface7_Release(render_target);
    }
    if (!depthStencil)
    {
        TRACE("Setting wined3d depth stencil to NULL\n");
        wined3d_device_set_depth_stencil_view(device->wined3d_device, NULL);
        return WINED3D_ZB_FALSE;
    }
 
    dsi = impl_from_IDirectDrawSurface7(depthStencil);
    wined3d_device_set_depth_stencil_view(device->wined3d_device,
            ddraw_surface_get_rendertarget_view(dsi));
 
    IDirectDrawSurface7_Release(depthStencil);
    return WINED3D_ZB_TRUE;
}

Referenced by d3d_device_init(), d3d_device_set_render_target(), and ddraw_surface_attach_surface().

d3d_execute_buffer_execute()

HRESULT d3d_execute_buffer_execute	(	struct d3d_execute_buffer *	execute_buffer,
		struct d3d_device *	device,
		struct d3d_viewport *	viewport
	)

Definition at line 51 of file executebuffer.c.

{
    DWORD is = buffer->data.dwInstructionOffset;
    char *instr = (char *)buffer->desc.lpData + is;
    unsigned int i, primitive_size;
    struct wined3d_map_desc map_desc;
    struct wined3d_box box = {0};
    HRESULT hr;
 
    if (viewport->active_device != device)
    {
        WARN("Viewport %p active device is %p.\n",
                viewport, viewport->active_device);
        return DDERR_INVALIDPARAMS;
    }
 
    /* Activate the viewport */
    viewport_activate(viewport, FALSE);
 
    TRACE("ExecuteData :\n");
    if (TRACE_ON(ddraw))
        _dump_executedata(&(buffer->data));
 
    for (;;)
    {
        D3DINSTRUCTION *current = (D3DINSTRUCTION *)instr;
        BYTE size;
        WORD count;
 
        count = current->wCount;
        size = current->bSize;
        instr += sizeof(*current);
        primitive_size = 0;
 
        switch (current->bOpcode)
        {
            case D3DOP_POINT:
            {
                const D3DPOINT *p = (D3DPOINT *)instr;
                wined3d_device_set_primitive_type(device->wined3d_device, WINED3D_PT_POINTLIST, 0);
                wined3d_device_set_stream_source(device->wined3d_device, 0,
                        buffer->dst_vertex_buffer, 0, sizeof(D3DTLVERTEX));
                wined3d_device_set_vertex_declaration(device->wined3d_device,
                        ddraw_find_decl(device->ddraw, D3DFVF_TLVERTEX));
 
                for (i = 0; i < count; ++i)
                    wined3d_device_draw_primitive(device->wined3d_device, p[i].wFirst, p[i].wCount);
 
                instr += sizeof(*p) * count;
                break;
            }
 
            case D3DOP_LINE:
                primitive_size = 2;
                wined3d_device_set_primitive_type(device->wined3d_device, WINED3D_PT_LINELIST, 0);
                /* Drop through. */
            case D3DOP_TRIANGLE:
            {
                WORD *indices;
                unsigned int index_pos = buffer->index_pos, index_count;
                TRACE("TRIANGLE         (%d)\n", count);
 
                if (!count)
                    break;
 
                if (!primitive_size)
                {
                    wined3d_device_set_primitive_type(device->wined3d_device, WINED3D_PT_TRIANGLELIST, 0);
                    primitive_size = 3;
                }
 
                index_count = count * primitive_size;
 
                if (buffer->index_size < index_count)
                {
                    unsigned int new_size = max(buffer->index_size * 2, index_count);
                    struct wined3d_buffer *new_buffer;
                    struct wined3d_buffer_desc desc;
 
                    desc.byte_width = new_size * sizeof(*indices);
                    desc.usage = WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_WRITEONLY | WINED3DUSAGE_STATICDECL;
                    desc.bind_flags = WINED3D_BIND_INDEX_BUFFER;
                    desc.access = WINED3D_RESOURCE_ACCESS_GPU
                            | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
                    desc.misc_flags = 0;
                    desc.structure_byte_stride = 0;
 
                    if (FAILED(hr = wined3d_buffer_create(device->wined3d_device, &desc,
                            NULL, NULL, &ddraw_null_wined3d_parent_ops, &new_buffer)))
                        return hr;
 
                    buffer->index_size = new_size;
                    if (buffer->index_buffer)
                        wined3d_buffer_decref(buffer->index_buffer);
                    buffer->index_buffer = new_buffer;
                    index_pos = 0;
                }
                else if (buffer->index_size - index_count < index_pos)
                {
                    index_pos = 0;
                }
 
                box.left = index_pos * sizeof(*indices);
                box.right = (index_pos + index_count) * sizeof(*indices);
                if (FAILED(hr = wined3d_resource_map(wined3d_buffer_get_resource(buffer->index_buffer), 0, &map_desc,
                        &box, WINED3D_MAP_WRITE | (index_pos ? WINED3D_MAP_NOOVERWRITE : WINED3D_MAP_DISCARD))))
                    return hr;
                indices = map_desc.data;
 
                for (i = 0; i < count; ++i)
                {
                    D3DTRIANGLE *ci = (D3DTRIANGLE *)instr;
                    TRACE("  v1: %d  v2: %d  v3: %d\n",ci->u1.v1, ci->u2.v2, ci->u3.v3);
                    TRACE("  Flags : ");
                    if (TRACE_ON(ddraw))
                    {
                        /* Wireframe */
                        if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1)
                            TRACE("EDGEENABLE1 ");
                        if (ci->wFlags & D3DTRIFLAG_EDGEENABLE2)
                            TRACE("EDGEENABLE2 ");
                        if (ci->wFlags & D3DTRIFLAG_EDGEENABLE1)
                            TRACE("EDGEENABLE3 ");
                        /* Strips / Fans */
                        if (ci->wFlags == D3DTRIFLAG_EVEN)
                            TRACE("EVEN ");
                        if (ci->wFlags == D3DTRIFLAG_ODD)
                            TRACE("ODD ");
                        if (ci->wFlags == D3DTRIFLAG_START)
                            TRACE("START ");
                        if ((ci->wFlags > 0) && (ci->wFlags < 30))
                            TRACE("STARTFLAT(%u) ", ci->wFlags);
                        TRACE("\n");
                    }
 
                    switch (primitive_size)
                    {
                        case 3:
                            indices[(i * primitive_size) + 2] = ci->u3.v3;
                            /* Drop through. */
                        case 2:
                            indices[(i * primitive_size) + 1] = ci->u2.v2;
                            indices[(i * primitive_size)    ] = ci->u1.v1;
                    }
                    instr += size;
                }
 
                wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->index_buffer), 0);
 
                wined3d_device_set_stream_source(device->wined3d_device, 0,
                        buffer->dst_vertex_buffer, 0, sizeof(D3DTLVERTEX));
                wined3d_device_set_vertex_declaration(device->wined3d_device,
                        ddraw_find_decl(device->ddraw, D3DFVF_TLVERTEX));
                wined3d_device_set_index_buffer(device->wined3d_device, buffer->index_buffer, WINED3DFMT_R16_UINT, 0);
                wined3d_device_draw_indexed_primitive(device->wined3d_device, index_pos, index_count);
 
                buffer->index_pos = index_pos + index_count;
                break;
            }
 
            case D3DOP_MATRIXLOAD:
                WARN("MATRIXLOAD-s     (%u)\n", count);
                instr += count * size;
                break;
 
            case D3DOP_MATRIXMULTIPLY:
                TRACE("MATRIXMULTIPLY   (%d)\n", count);
                for (i = 0; i < count; ++i)
                {
                    D3DMATRIXMULTIPLY *ci = (D3DMATRIXMULTIPLY *)instr;
                    D3DMATRIX *a, *b, *c;
 
                    a = ddraw_get_object(&device->handle_table, ci->hDestMatrix - 1, DDRAW_HANDLE_MATRIX);
                    b = ddraw_get_object(&device->handle_table, ci->hSrcMatrix1 - 1, DDRAW_HANDLE_MATRIX);
                    c = ddraw_get_object(&device->handle_table, ci->hSrcMatrix2 - 1, DDRAW_HANDLE_MATRIX);
 
                    if (!a || !b || !c)
                    {
                        ERR("Invalid matrix handle (a %#x -> %p, b %#x -> %p, c %#x -> %p).\n",
                                ci->hDestMatrix, a, ci->hSrcMatrix1, b, ci->hSrcMatrix2, c);
                    }
                    else
                    {
                        TRACE("dst %p, src1 %p, src2 %p.\n", a, b, c);
                        multiply_matrix(a, c, b);
                    }
 
                    instr += size;
                }
                break;
 
            case D3DOP_STATETRANSFORM:
                TRACE("STATETRANSFORM   (%d)\n", count);
                for (i = 0; i < count; ++i)
                {
                    D3DSTATE *ci = (D3DSTATE *)instr;
                    D3DMATRIX *m;
 
                    m = ddraw_get_object(&device->handle_table, ci->u2.dwArg[0] - 1, DDRAW_HANDLE_MATRIX);
                    if (!m)
                    {
                        ERR("Invalid matrix handle %#x.\n", ci->u2.dwArg[0]);
                    }
                    else
                    {
                        if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_WORLD)
                            device->world = ci->u2.dwArg[0];
                        if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_VIEW)
                            device->view = ci->u2.dwArg[0];
                        if (ci->u1.dtstTransformStateType == D3DTRANSFORMSTATE_PROJECTION)
                            device->proj = ci->u2.dwArg[0];
                        IDirect3DDevice3_SetTransform(&device->IDirect3DDevice3_iface,
                                ci->u1.dtstTransformStateType, m);
                    }
 
                    instr += size;
                }
                break;
 
            case D3DOP_STATELIGHT:
                TRACE("STATELIGHT       (%d)\n", count);
                for (i = 0; i < count; ++i)
                {
                    D3DSTATE *ci = (D3DSTATE *)instr;
 
                    if (FAILED(IDirect3DDevice3_SetLightState(&device->IDirect3DDevice3_iface,
                            ci->u1.dlstLightStateType, ci->u2.dwArg[0])))
                        WARN("Failed to set light state.\n");
 
                    instr += size;
                }
                break;
 
            case D3DOP_STATERENDER:
                TRACE("STATERENDER      (%d)\n", count);
                for (i = 0; i < count; ++i)
                {
                    D3DSTATE *ci = (D3DSTATE *)instr;
 
                    if (FAILED(IDirect3DDevice3_SetRenderState(&device->IDirect3DDevice3_iface,
                            ci->u1.drstRenderStateType, ci->u2.dwArg[0])))
                        WARN("Failed to set render state.\n");
 
                    instr += size;
                }
                break;
 
            case D3DOP_PROCESSVERTICES:
                TRACE("PROCESSVERTICES  (%d)\n", count);
 
                for (i = 0; i < count; ++i)
                {
                    D3DPROCESSVERTICES *ci = (D3DPROCESSVERTICES *)instr;
                    DWORD op = ci->dwFlags & D3DPROCESSVERTICES_OPMASK;
 
                    TRACE("  start %u, dest %u, count %u, flags %#x.\n",
                            ci->wStart, ci->wDest, ci->dwCount, ci->dwFlags);
 
                    if (ci->dwFlags & D3DPROCESSVERTICES_UPDATEEXTENTS)
                    {
                        static int once;
                        if (!once++) FIXME("D3DPROCESSVERTICES_UPDATEEXTENTS not implemented.\n");
                    }
                    if (ci->dwFlags & D3DPROCESSVERTICES_NOCOLOR)
                        FIXME("D3DPROCESSVERTICES_NOCOLOR not implemented.\n");
 
                    switch (op)
                    {
                        case D3DPROCESSVERTICES_TRANSFORMLIGHT:
                        case D3DPROCESSVERTICES_TRANSFORM:
                            wined3d_device_set_stream_source(device->wined3d_device, 0,
                                    buffer->src_vertex_buffer, buffer->src_vertex_pos, sizeof(D3DVERTEX));
                            if (op == D3DPROCESSVERTICES_TRANSFORMLIGHT)
                            {
                                wined3d_device_set_vertex_declaration(device->wined3d_device,
                                        ddraw_find_decl(device->ddraw, D3DFVF_VERTEX));
                                wined3d_device_set_render_state(device->wined3d_device,
                                        WINED3D_RS_LIGHTING, TRUE);
                            }
                            else
                            {
                                wined3d_device_set_vertex_declaration(device->wined3d_device,
                                        ddraw_find_decl(device->ddraw, D3DFVF_LVERTEX));
                                wined3d_device_set_render_state(device->wined3d_device,
                                        WINED3D_RS_LIGHTING, FALSE);
                            }
 
                            wined3d_device_process_vertices(device->wined3d_device, ci->wStart, ci->wDest,
                                    ci->dwCount, buffer->dst_vertex_buffer, NULL, 0, D3DFVF_TLVERTEX);
                            break;
 
                        case D3DPROCESSVERTICES_COPY:
                            box.left = (buffer->src_vertex_pos + ci->wStart) * sizeof(D3DTLVERTEX);
                            box.right = box.left + ci->dwCount * sizeof(D3DTLVERTEX);
                            box.top = box.front = 0;
                            box.bottom = box.back = 1;
                            wined3d_device_copy_sub_resource_region(device->wined3d_device,
                                    wined3d_buffer_get_resource(buffer->dst_vertex_buffer), 0,
                                    ci->wDest * sizeof(D3DTLVERTEX), 0, 0,
                                    wined3d_buffer_get_resource(buffer->src_vertex_buffer), 0, &box);
                            break;
 
                        default:
                            FIXME("Unhandled vertex processing op %#x.\n", op);
                            break;
                    }
 
                    instr += size;
                }
                break;
 
            case D3DOP_TEXTURELOAD:
                TRACE("TEXTURELOAD    (%u)\n", count);
 
                for (i = 0; i < count; ++i)
                {
                    D3DTEXTURELOAD *ci = (D3DTEXTURELOAD *)instr;
                    struct ddraw_surface *dst, *src;
 
                    instr += size;
 
                    if (!(dst = ddraw_get_object(&device->handle_table,
                            ci->hDestTexture - 1, DDRAW_HANDLE_SURFACE)))
                    {
                        WARN("Invalid destination texture handle %#x.\n", ci->hDestTexture);
                        continue;
                    }
                    if (!(src = ddraw_get_object(&device->handle_table,
                            ci->hSrcTexture - 1, DDRAW_HANDLE_SURFACE)))
                    {
                        WARN("Invalid source texture handle %#x.\n", ci->hSrcTexture);
                        continue;
                    }
 
                    IDirect3DTexture2_Load(&dst->IDirect3DTexture2_iface, &src->IDirect3DTexture2_iface);
                }
                break;
 
            case D3DOP_EXIT:
                TRACE("EXIT             (%u)\n", count);
                instr += size;
                goto end_of_buffer;
 
            case D3DOP_BRANCHFORWARD:
                TRACE("BRANCHFORWARD    (%d)\n", count);
                for (i = 0; i < count; ++i)
                {
                    D3DBRANCH *ci = (D3DBRANCH *)instr;
 
                    if ((buffer->data.dsStatus.dwStatus & ci->dwMask) == ci->dwValue)
                    {
                        if (!ci->bNegate)
                        {
                            TRACE(" Branch to %d\n", ci->dwOffset);
                            if (ci->dwOffset) {
                                instr = (char*)current + ci->dwOffset;
                                break;
                            }
                        }
                    }
                    else
                    {
                        if (ci->bNegate)
                        {
                            TRACE(" Branch to %d\n", ci->dwOffset);
                            if (ci->dwOffset) {
                                instr = (char*)current + ci->dwOffset;
                                break;
                            }
                        }
                    }
 
                    instr += size;
                }
                break;
 
            case D3DOP_SPAN:
                WARN("SPAN-s           (%u)\n", count);
                instr += count * size;
                break;
 
            case D3DOP_SETSTATUS:
                TRACE("SETSTATUS        (%d)\n", count);
                for (i = 0; i < count; ++i)
                {
                    buffer->data.dsStatus = *(D3DSTATUS *)instr;
                    instr += size;
                }
                break;
 
            default:
                ERR("Unhandled OpCode %#x.\n",current->bOpcode);
                instr += count * size;
                break;
        }
    }
 
end_of_buffer:
    return D3D_OK;
}

Referenced by d3d_device1_Execute().

d3d_execute_buffer_init()

HRESULT d3d_execute_buffer_init	(	struct d3d_execute_buffer *	execute_buffer,
		struct d3d_device *	device,
		D3DEXECUTEBUFFERDESC *	desc
	)

Definition at line 775 of file executebuffer.c.

{
    execute_buffer->IDirect3DExecuteBuffer_iface.lpVtbl = &d3d_execute_buffer_vtbl;
    execute_buffer->ref = 1;
    execute_buffer->d3ddev = device;
 
    /* Initializes memory */
    memcpy(&execute_buffer->desc, desc, desc->dwSize);
 
    /* No buffer given */
    if (!(execute_buffer->desc.dwFlags & D3DDEB_LPDATA))
        execute_buffer->desc.lpData = NULL;
 
    /* No buffer size given */
    if (!(execute_buffer->desc.dwFlags & D3DDEB_BUFSIZE))
        execute_buffer->desc.dwBufferSize = 0;
 
    /* Create buffer if asked */
    if (!execute_buffer->desc.lpData && execute_buffer->desc.dwBufferSize)
    {
        execute_buffer->need_free = TRUE;
        if (!(execute_buffer->desc.lpData = heap_alloc_zero(execute_buffer->desc.dwBufferSize)))
        {
            ERR("Failed to allocate execute buffer data.\n");
            return DDERR_OUTOFMEMORY;
        }
    }
 
    execute_buffer->desc.dwFlags |= D3DDEB_LPDATA;
 
    return D3D_OK;
}

Referenced by d3d_device1_CreateExecuteBuffer().

d3d_light_init()

void d3d_light_init	(	struct d3d_light *	light,
		struct ddraw *	ddraw
	)

Definition at line 247 of file light.c.

{
    light->IDirect3DLight_iface.lpVtbl = &d3d_light_vtbl;
    light->ref = 1;
    light->ddraw = ddraw;
}

Referenced by d3d3_CreateLight().

d3d_material_create()

struct d3d_material * d3d_material_create

(

struct ddraw *

ddraw

)

Definition at line 501 of file material.c.

{
    struct d3d_material *material;
 
    if (!(material = heap_alloc_zero(sizeof(*material))))
        return NULL;
 
    material->IDirect3DMaterial3_iface.lpVtbl = &d3d_material3_vtbl;
    material->IDirect3DMaterial2_iface.lpVtbl = &d3d_material2_vtbl;
    material->IDirect3DMaterial_iface.lpVtbl = &d3d_material1_vtbl;
    material->ref = 1;
    material->ddraw = ddraw;
 
    return material;
}

Referenced by d3d1_CreateMaterial(), d3d2_CreateMaterial(), and d3d3_CreateMaterial().

d3d_vertex_buffer_create()

HRESULT d3d_vertex_buffer_create	(	struct d3d_vertex_buffer **	buffer,
		struct ddraw *	ddraw,
		D3DVERTEXBUFFERDESC *	desc
	)

Definition at line 432 of file vertexbuffer.c.

{
    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);
 
    if (!(buffer = heap_alloc_zero(sizeof(*buffer))))
        return DDERR_OUTOFMEMORY;
 
    buffer->IDirect3DVertexBuffer7_iface.lpVtbl = &d3d_vertex_buffer7_vtbl;
    buffer->ref = 1;
    buffer->version = ddraw->d3dversion;
    if (buffer->version == 7)
        IDirectDraw7_AddRef(&ddraw->IDirectDraw7_iface);
    buffer->ddraw = ddraw;
    buffer->Caps = desc->dwCaps;
    buffer->fvf = desc->dwFVF;
    buffer->size = get_flexible_vertex_size(desc->dwFVF) * desc->dwNumVertices;
 
    wined3d_mutex_lock();
 
    if (FAILED(hr = d3d_vertex_buffer_create_wined3d_buffer(buffer, FALSE, &buffer->wined3d_buffer)))
    {
        WARN("Failed to create wined3d vertex buffer, hr %#x.\n", hr);
        if (hr == WINED3DERR_INVALIDCALL)
            hr = DDERR_INVALIDPARAMS;
        goto end;
    }
 
    if (!(buffer->wined3d_declaration = ddraw_find_decl(ddraw, desc->dwFVF)))
    {
        ERR("Failed to find vertex declaration for fvf %#x.\n", desc->dwFVF);
        wined3d_buffer_decref(buffer->wined3d_buffer);
        hr = DDERR_INVALIDPARAMS;
        goto end;
    }
    wined3d_vertex_declaration_incref(buffer->wined3d_declaration);
 
end:
    wined3d_mutex_unlock();
    if (hr == D3D_OK)
        *vertex_buf = buffer;
    else
        heap_free(buffer);
 
    return hr;
}

Referenced by d3d3_CreateVertexBuffer(), and d3d7_CreateVertexBuffer().

d3d_viewport_init()

void d3d_viewport_init	(	struct d3d_viewport *	viewport,
		struct ddraw *	ddraw
	)

Definition at line 1146 of file viewport.c.

{
    viewport->IDirect3DViewport3_iface.lpVtbl = &d3d_viewport_vtbl;
    viewport->ref = 1;
    viewport->ddraw = ddraw;
    viewport->use_vp2 = 0xff;
    list_init(&viewport->light_list);
}

Referenced by d3d3_CreateViewport().

ddraw_allocate_handle()

DWORD ddraw_allocate_handle	(	struct ddraw_handle_table *	t,
		void *	object,
		enum ddraw_handle_type	type
	)

Definition at line 113 of file main.c.

{
    struct ddraw_handle_entry *entry;
 
    if (t->free_entries)
    {
        DWORD idx = t->free_entries - t->entries;
        /* Use a free handle */
        entry = t->free_entries;
        if (entry->type != DDRAW_HANDLE_FREE)
        {
            ERR("Handle %#x (%p) is in the free list, but has type %#x.\n", idx, entry->object, entry->type);
            return DDRAW_INVALID_HANDLE;
        }
        t->free_entries = entry->object;
        entry->object = object;
        entry->type = type;
 
        return idx;
    }
 
    if (!(t->entry_count < t->table_size))
    {
        /* Grow the table */
        UINT new_size = t->table_size + (t->table_size >> 1);
        struct ddraw_handle_entry *new_entries;
 
        if (!(new_entries = heap_realloc(t->entries, new_size * sizeof(*t->entries))))
        {
            ERR("Failed to grow the handle table.\n");
            return DDRAW_INVALID_HANDLE;
        }
        t->entries = new_entries;
        t->table_size = new_size;
    }
 
    entry = &t->entries[t->entry_count];
    entry->object = object;
    entry->type = type;
 
    return t->entry_count++;
}

Referenced by d3d_device1_CreateMatrix(), d3d_device7_CreateStateBlock(), d3d_device7_EndStateBlock(), d3d_material3_GetHandle(), and d3d_texture2_GetHandle().

ddraw_clipper_init()

HRESULT ddraw_clipper_init

(

struct ddraw_clipper *

clipper

)

Definition at line 321 of file clipper.c.

{
    clipper->IDirectDrawClipper_iface.lpVtbl = &ddraw_clipper_vtbl;
    clipper->ref = 1;
 
    return DD_OK;
}

Referenced by DirectDrawCreateClipper().

DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1()

void DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1	(	const DDDEVICEIDENTIFIER2 *	pIn,
		DDDEVICEIDENTIFIER *	pOut
	)

Definition at line 961 of file utils.c.

{
    /* 2 adds a dwWHQLLevel field to the end. Both structures are
     * unversioned. */
    memcpy(pOut, pIn, sizeof(*pOut));
}

Referenced by ddraw4_GetDeviceIdentifier().

DDRAW_Convert_DDSCAPS_1_To_2()

void DDRAW_Convert_DDSCAPS_1_To_2	(	const DDSCAPS *	pIn,
		DDSCAPS2 *	pOut
	)

Definition at line 951 of file utils.c.

{
    /* 2 adds three additional caps fields to the end. Both versions
     * are unversioned. */
    pOut->dwCaps = pIn->dwCaps;
    pOut->dwCaps2 = 0;
    pOut->dwCaps3 = 0;
    pOut->u1.dwCaps4 = 0;
}

Referenced by ddraw2_GetAvailableVidMem().

ddraw_d3dcaps1_from_7()

void ddraw_d3dcaps1_from_7	(	D3DDEVICEDESC *	caps1,
		D3DDEVICEDESC7 *	caps7
	)

Definition at line 1192 of file ddraw.c.

{
    memset(caps1, 0, sizeof(*caps1));
    caps1->dwSize = sizeof(*caps1);
    caps1->dwFlags = D3DDD_COLORMODEL
            | D3DDD_DEVCAPS
            | D3DDD_TRANSFORMCAPS
            | D3DDD_BCLIPPING
            | D3DDD_LIGHTINGCAPS
            | D3DDD_LINECAPS
            | D3DDD_TRICAPS
            | D3DDD_DEVICERENDERBITDEPTH
            | D3DDD_DEVICEZBUFFERBITDEPTH
            | D3DDD_MAXBUFFERSIZE
            | D3DDD_MAXVERTEXCOUNT;
    caps1->dcmColorModel = D3DCOLOR_RGB;
    caps1->dwDevCaps = caps7->dwDevCaps;
    caps1->dtcTransformCaps.dwSize = sizeof(caps1->dtcTransformCaps);
    caps1->dtcTransformCaps.dwCaps = D3DTRANSFORMCAPS_CLIP;
    caps1->bClipping = TRUE;
    caps1->dlcLightingCaps.dwSize = sizeof(caps1->dlcLightingCaps);
    caps1->dlcLightingCaps.dwCaps = D3DLIGHTCAPS_DIRECTIONAL
            | D3DLIGHTCAPS_PARALLELPOINT
            | D3DLIGHTCAPS_POINT
            | D3DLIGHTCAPS_SPOT;
    caps1->dlcLightingCaps.dwLightingModel = D3DLIGHTINGMODEL_RGB;
    caps1->dlcLightingCaps.dwNumLights = caps7->dwMaxActiveLights;
    caps1->dpcLineCaps = caps7->dpcLineCaps;
    caps1->dpcTriCaps = caps7->dpcTriCaps;
    caps1->dwDeviceRenderBitDepth = caps7->dwDeviceRenderBitDepth;
    caps1->dwDeviceZBufferBitDepth = caps7->dwDeviceZBufferBitDepth;
    caps1->dwMaxBufferSize = 0;
    caps1->dwMaxVertexCount = 65536;
    caps1->dwMinTextureWidth  = caps7->dwMinTextureWidth;
    caps1->dwMinTextureHeight = caps7->dwMinTextureHeight;
    caps1->dwMaxTextureWidth  = caps7->dwMaxTextureWidth;
    caps1->dwMaxTextureHeight = caps7->dwMaxTextureHeight;
    caps1->dwMinStippleWidth  = 1;
    caps1->dwMinStippleHeight = 1;
    caps1->dwMaxStippleWidth  = 32;
    caps1->dwMaxStippleHeight = 32;
    caps1->dwMaxTextureRepeat = caps7->dwMaxTextureRepeat;
    caps1->dwMaxTextureAspectRatio = caps7->dwMaxTextureAspectRatio;
    caps1->dwMaxAnisotropy = caps7->dwMaxAnisotropy;
    caps1->dvGuardBandLeft = caps7->dvGuardBandLeft;
    caps1->dvGuardBandTop = caps7->dvGuardBandTop;
    caps1->dvGuardBandRight = caps7->dvGuardBandRight;
    caps1->dvGuardBandBottom = caps7->dvGuardBandBottom;
    caps1->dvExtentsAdjust = caps7->dvExtentsAdjust;
    caps1->dwStencilCaps = caps7->dwStencilCaps;
    caps1->dwFVFCaps = caps7->dwFVFCaps;
    caps1->dwTextureOpCaps = caps7->dwTextureOpCaps;
    caps1->wMaxTextureBlendStages = caps7->wMaxTextureBlendStages;
    caps1->wMaxSimultaneousTextures = caps7->wMaxSimultaneousTextures;
}

Referenced by d3d3_EnumDevices(), d3d3_FindDevice(), and d3d_device3_GetCaps().

DDRAW_dump_cooperativelevel()

void DDRAW_dump_cooperativelevel

(

DWORD

cooplevel

)

Definition at line 968 of file utils.c.

{
    static const struct flag_info flags[] =
    {
        FE(DDSCL_FULLSCREEN),
        FE(DDSCL_ALLOWREBOOT),
        FE(DDSCL_NOWINDOWCHANGES),
        FE(DDSCL_NORMAL),
        FE(DDSCL_ALLOWMODEX),
        FE(DDSCL_EXCLUSIVE),
        FE(DDSCL_SETFOCUSWINDOW),
        FE(DDSCL_SETDEVICEWINDOW),
        FE(DDSCL_CREATEDEVICEWINDOW)
    };
 
    if (TRACE_ON(ddraw))
    {
        TRACE(" - ");
        DDRAW_dump_flags(cooplevel, flags, ARRAY_SIZE(flags));
    }
}

Referenced by ddraw_set_cooperative_level().

DDRAW_dump_DDCAPS()

void DDRAW_dump_DDCAPS

(

const DDCAPS *

lpcaps

)

Definition at line 990 of file utils.c.

{
    static const struct flag_info flags1[] =
    {
        FE(DDCAPS_3D),
        FE(DDCAPS_ALIGNBOUNDARYDEST),
        FE(DDCAPS_ALIGNSIZEDEST),
        FE(DDCAPS_ALIGNBOUNDARYSRC),
        FE(DDCAPS_ALIGNSIZESRC),
        FE(DDCAPS_ALIGNSTRIDE),
        FE(DDCAPS_BLT),
        FE(DDCAPS_BLTQUEUE),
        FE(DDCAPS_BLTFOURCC),
        FE(DDCAPS_BLTSTRETCH),
        FE(DDCAPS_GDI),
        FE(DDCAPS_OVERLAY),
        FE(DDCAPS_OVERLAYCANTCLIP),
        FE(DDCAPS_OVERLAYFOURCC),
        FE(DDCAPS_OVERLAYSTRETCH),
        FE(DDCAPS_PALETTE),
        FE(DDCAPS_PALETTEVSYNC),
        FE(DDCAPS_READSCANLINE),
        FE(DDCAPS_STEREOVIEW),
        FE(DDCAPS_VBI),
        FE(DDCAPS_ZBLTS),
        FE(DDCAPS_ZOVERLAYS),
        FE(DDCAPS_COLORKEY),
        FE(DDCAPS_ALPHA),
        FE(DDCAPS_COLORKEYHWASSIST),
        FE(DDCAPS_NOHARDWARE),
        FE(DDCAPS_BLTCOLORFILL),
        FE(DDCAPS_BANKSWITCHED),
        FE(DDCAPS_BLTDEPTHFILL),
        FE(DDCAPS_CANCLIP),
        FE(DDCAPS_CANCLIPSTRETCHED),
        FE(DDCAPS_CANBLTSYSMEM)
    };
    static const struct flag_info flags2[] =
    {
        FE(DDCAPS2_CERTIFIED),
        FE(DDCAPS2_NO2DDURING3DSCENE),
        FE(DDCAPS2_VIDEOPORT),
        FE(DDCAPS2_AUTOFLIPOVERLAY),
        FE(DDCAPS2_CANBOBINTERLEAVED),
        FE(DDCAPS2_CANBOBNONINTERLEAVED),
        FE(DDCAPS2_COLORCONTROLOVERLAY),
        FE(DDCAPS2_COLORCONTROLPRIMARY),
        FE(DDCAPS2_CANDROPZ16BIT),
        FE(DDCAPS2_NONLOCALVIDMEM),
        FE(DDCAPS2_NONLOCALVIDMEMCAPS),
        FE(DDCAPS2_NOPAGELOCKREQUIRED),
        FE(DDCAPS2_WIDESURFACES),
        FE(DDCAPS2_CANFLIPODDEVEN),
        FE(DDCAPS2_CANBOBHARDWARE),
        FE(DDCAPS2_COPYFOURCC),
        FE(DDCAPS2_PRIMARYGAMMA),
        FE(DDCAPS2_CANRENDERWINDOWED),
        FE(DDCAPS2_CANCALIBRATEGAMMA),
        FE(DDCAPS2_FLIPINTERVAL),
        FE(DDCAPS2_FLIPNOVSYNC),
        FE(DDCAPS2_CANMANAGETEXTURE),
        FE(DDCAPS2_TEXMANINNONLOCALVIDMEM),
        FE(DDCAPS2_STEREO),
        FE(DDCAPS2_SYSTONONLOCAL_AS_SYSTOLOCAL)
    };
    static const struct flag_info flags3[] =
    {
        FE(DDCKEYCAPS_DESTBLT),
        FE(DDCKEYCAPS_DESTBLTCLRSPACE),
        FE(DDCKEYCAPS_DESTBLTCLRSPACEYUV),
        FE(DDCKEYCAPS_DESTBLTYUV),
        FE(DDCKEYCAPS_DESTOVERLAY),
        FE(DDCKEYCAPS_DESTOVERLAYCLRSPACE),
        FE(DDCKEYCAPS_DESTOVERLAYCLRSPACEYUV),
        FE(DDCKEYCAPS_DESTOVERLAYONEACTIVE),
        FE(DDCKEYCAPS_DESTOVERLAYYUV),
        FE(DDCKEYCAPS_SRCBLT),
        FE(DDCKEYCAPS_SRCBLTCLRSPACE),
        FE(DDCKEYCAPS_SRCBLTCLRSPACEYUV),
        FE(DDCKEYCAPS_SRCBLTYUV),
        FE(DDCKEYCAPS_SRCOVERLAY),
        FE(DDCKEYCAPS_SRCOVERLAYCLRSPACE),
        FE(DDCKEYCAPS_SRCOVERLAYCLRSPACEYUV),
        FE(DDCKEYCAPS_SRCOVERLAYONEACTIVE),
        FE(DDCKEYCAPS_SRCOVERLAYYUV),
        FE(DDCKEYCAPS_NOCOSTOVERLAY)
    };
    static const struct flag_info flags4[] =
    {
        FE(DDFXCAPS_BLTALPHA),
        FE(DDFXCAPS_OVERLAYALPHA),
        FE(DDFXCAPS_BLTARITHSTRETCHYN),
        FE(DDFXCAPS_BLTARITHSTRETCHY),
        FE(DDFXCAPS_BLTMIRRORLEFTRIGHT),
        FE(DDFXCAPS_BLTMIRRORUPDOWN),
        FE(DDFXCAPS_BLTROTATION),
        FE(DDFXCAPS_BLTROTATION90),
        FE(DDFXCAPS_BLTSHRINKX),
        FE(DDFXCAPS_BLTSHRINKXN),
        FE(DDFXCAPS_BLTSHRINKY),
        FE(DDFXCAPS_BLTSHRINKYN),
        FE(DDFXCAPS_BLTSTRETCHX),
        FE(DDFXCAPS_BLTSTRETCHXN),
        FE(DDFXCAPS_BLTSTRETCHY),
        FE(DDFXCAPS_BLTSTRETCHYN),
        FE(DDFXCAPS_OVERLAYARITHSTRETCHY),
        FE(DDFXCAPS_OVERLAYARITHSTRETCHYN),
        FE(DDFXCAPS_OVERLAYSHRINKX),
        FE(DDFXCAPS_OVERLAYSHRINKXN),
        FE(DDFXCAPS_OVERLAYSHRINKY),
        FE(DDFXCAPS_OVERLAYSHRINKYN),
        FE(DDFXCAPS_OVERLAYSTRETCHX),
        FE(DDFXCAPS_OVERLAYSTRETCHXN),
        FE(DDFXCAPS_OVERLAYSTRETCHY),
        FE(DDFXCAPS_OVERLAYSTRETCHYN),
        FE(DDFXCAPS_OVERLAYMIRRORLEFTRIGHT),
        FE(DDFXCAPS_OVERLAYMIRRORUPDOWN)
    };
    static const struct flag_info flags5[] =
    {
        FE(DDFXALPHACAPS_BLTALPHAEDGEBLEND),
        FE(DDFXALPHACAPS_BLTALPHAPIXELS),
        FE(DDFXALPHACAPS_BLTALPHAPIXELSNEG),
        FE(DDFXALPHACAPS_BLTALPHASURFACES),
        FE(DDFXALPHACAPS_BLTALPHASURFACESNEG),
        FE(DDFXALPHACAPS_OVERLAYALPHAEDGEBLEND),
        FE(DDFXALPHACAPS_OVERLAYALPHAPIXELS),
        FE(DDFXALPHACAPS_OVERLAYALPHAPIXELSNEG),
        FE(DDFXALPHACAPS_OVERLAYALPHASURFACES),
        FE(DDFXALPHACAPS_OVERLAYALPHASURFACESNEG)
    };
    static const struct flag_info flags6[] =
    {
        FE(DDPCAPS_4BIT),
        FE(DDPCAPS_8BITENTRIES),
        FE(DDPCAPS_8BIT),
        FE(DDPCAPS_INITIALIZE),
        FE(DDPCAPS_PRIMARYSURFACE),
        FE(DDPCAPS_PRIMARYSURFACELEFT),
        FE(DDPCAPS_ALLOW256),
        FE(DDPCAPS_VSYNC),
        FE(DDPCAPS_1BIT),
        FE(DDPCAPS_2BIT),
        FE(DDPCAPS_ALPHA),
    };
    static const struct flag_info flags7[] =
    {
        FE(DDSVCAPS_RESERVED1),
        FE(DDSVCAPS_RESERVED2),
        FE(DDSVCAPS_RESERVED3),
        FE(DDSVCAPS_RESERVED4),
        FE(DDSVCAPS_STEREOSEQUENTIAL),
    };
 
    TRACE(" - dwSize : %d\n", lpcaps->dwSize);
    TRACE(" - dwCaps : "); DDRAW_dump_flags(lpcaps->dwCaps, flags1, ARRAY_SIZE(flags1));
    TRACE(" - dwCaps2 : "); DDRAW_dump_flags(lpcaps->dwCaps2, flags2, ARRAY_SIZE(flags2));
    TRACE(" - dwCKeyCaps : "); DDRAW_dump_flags(lpcaps->dwCKeyCaps, flags3, ARRAY_SIZE(flags3));
    TRACE(" - dwFXCaps : "); DDRAW_dump_flags(lpcaps->dwFXCaps, flags4, ARRAY_SIZE(flags4));
    TRACE(" - dwFXAlphaCaps : "); DDRAW_dump_flags(lpcaps->dwFXAlphaCaps, flags5, ARRAY_SIZE(flags5));
    TRACE(" - dwPalCaps : "); DDRAW_dump_flags(lpcaps->dwPalCaps, flags6, ARRAY_SIZE(flags6));
    TRACE(" - dwSVCaps : "); DDRAW_dump_flags(lpcaps->dwSVCaps, flags7, ARRAY_SIZE(flags7));
    TRACE("...\n");
    TRACE(" - dwNumFourCCCodes : %d\n", lpcaps->dwNumFourCCCodes);
    TRACE(" - dwCurrVisibleOverlays : %d\n", lpcaps->dwCurrVisibleOverlays);
    TRACE(" - dwMinOverlayStretch : %d\n", lpcaps->dwMinOverlayStretch);
    TRACE(" - dwMaxOverlayStretch : %d\n", lpcaps->dwMaxOverlayStretch);
    TRACE("...\n");
    TRACE(" - ddsCaps : "); DDRAW_dump_DDSCAPS2(&lpcaps->ddsCaps);
}

Referenced by ddraw7_GetCaps().

DDRAW_dump_DDSCAPS2()

void DDRAW_dump_DDSCAPS2

(

const DDSCAPS2 *

in

)

Definition at line 713 of file utils.c.

{
    static const struct flag_info flags[] =
    {
        FE(DDSCAPS_RESERVED1),
        FE(DDSCAPS_ALPHA),
        FE(DDSCAPS_BACKBUFFER),
        FE(DDSCAPS_COMPLEX),
        FE(DDSCAPS_FLIP),
        FE(DDSCAPS_FRONTBUFFER),
        FE(DDSCAPS_OFFSCREENPLAIN),
        FE(DDSCAPS_OVERLAY),
        FE(DDSCAPS_PALETTE),
        FE(DDSCAPS_PRIMARYSURFACE),
        FE(DDSCAPS_PRIMARYSURFACELEFT),
        FE(DDSCAPS_SYSTEMMEMORY),
        FE(DDSCAPS_TEXTURE),
        FE(DDSCAPS_3DDEVICE),
        FE(DDSCAPS_VIDEOMEMORY),
        FE(DDSCAPS_VISIBLE),
        FE(DDSCAPS_WRITEONLY),
        FE(DDSCAPS_ZBUFFER),
        FE(DDSCAPS_OWNDC),
        FE(DDSCAPS_LIVEVIDEO),
        FE(DDSCAPS_HWCODEC),
        FE(DDSCAPS_MODEX),
        FE(DDSCAPS_MIPMAP),
        FE(DDSCAPS_RESERVED2),
        FE(DDSCAPS_ALLOCONLOAD),
        FE(DDSCAPS_VIDEOPORT),
        FE(DDSCAPS_LOCALVIDMEM),
        FE(DDSCAPS_NONLOCALVIDMEM),
        FE(DDSCAPS_STANDARDVGAMODE),
        FE(DDSCAPS_OPTIMIZED)
    };
    static const struct flag_info flags2[] =
    {
        FE(DDSCAPS2_HARDWAREDEINTERLACE),
        FE(DDSCAPS2_HINTDYNAMIC),
        FE(DDSCAPS2_HINTSTATIC),
        FE(DDSCAPS2_TEXTUREMANAGE),
        FE(DDSCAPS2_RESERVED1),
        FE(DDSCAPS2_RESERVED2),
        FE(DDSCAPS2_OPAQUE),
        FE(DDSCAPS2_HINTANTIALIASING),
        FE(DDSCAPS2_CUBEMAP),
        FE(DDSCAPS2_CUBEMAP_POSITIVEX),
        FE(DDSCAPS2_CUBEMAP_NEGATIVEX),
        FE(DDSCAPS2_CUBEMAP_POSITIVEY),
        FE(DDSCAPS2_CUBEMAP_NEGATIVEY),
        FE(DDSCAPS2_CUBEMAP_POSITIVEZ),
        FE(DDSCAPS2_CUBEMAP_NEGATIVEZ),
        FE(DDSCAPS2_MIPMAPSUBLEVEL),
        FE(DDSCAPS2_D3DTEXTUREMANAGE),
        FE(DDSCAPS2_DONOTPERSIST),
        FE(DDSCAPS2_STEREOSURFACELEFT)
    };
 
    DDRAW_dump_flags_nolf(in->dwCaps, flags, ARRAY_SIZE(flags));
    DDRAW_dump_flags(in->dwCaps2, flags2, ARRAY_SIZE(flags2));
}

Referenced by ddraw7_GetAvailableVidMem(), DDRAW_dump_DDCAPS(), DDRAW_dump_DDSCAPS(), and DDRAW_dump_surface_desc().

DDRAW_dump_surface_desc()

void DDRAW_dump_surface_desc

(

const DDSURFACEDESC2 *

lpddsd

)

Definition at line 864 of file utils.c.

{
#define STRUCT DDSURFACEDESC2
    static const struct member_info members[] =
    {
        ME(DDSD_HEIGHT, DDRAW_dump_DWORD, dwHeight),
        ME(DDSD_WIDTH, DDRAW_dump_DWORD, dwWidth),
        ME(DDSD_PITCH, DDRAW_dump_DWORD, u1 /* lPitch */),
        ME(DDSD_LINEARSIZE, DDRAW_dump_DWORD, u1 /* dwLinearSize */),
        ME(DDSD_BACKBUFFERCOUNT, DDRAW_dump_DWORD, u5.dwBackBufferCount),
        ME(DDSD_MIPMAPCOUNT, DDRAW_dump_DWORD, u2 /* dwMipMapCount */),
        ME(DDSD_ZBUFFERBITDEPTH, DDRAW_dump_DWORD, u2 /* dwZBufferBitDepth */), /* This is for 'old-style' D3D */
        ME(DDSD_REFRESHRATE, DDRAW_dump_DWORD, u2 /* dwRefreshRate */),
        ME(DDSD_ALPHABITDEPTH, DDRAW_dump_DWORD, dwAlphaBitDepth),
        ME(DDSD_LPSURFACE, DDRAW_dump_PTR, lpSurface),
        ME(DDSD_CKDESTOVERLAY, DDRAW_dump_DDCOLORKEY, u3 /* ddckCKDestOverlay */),
        ME(DDSD_CKDESTBLT, DDRAW_dump_DDCOLORKEY, ddckCKDestBlt),
        ME(DDSD_CKSRCOVERLAY, DDRAW_dump_DDCOLORKEY, ddckCKSrcOverlay),
        ME(DDSD_CKSRCBLT, DDRAW_dump_DDCOLORKEY, ddckCKSrcBlt),
        ME(DDSD_PIXELFORMAT, DDRAW_dump_pixelformat, u4 /* ddpfPixelFormat */)
    };
    static const struct member_info members_caps[] =
    {
        ME(DDSD_CAPS, DDRAW_dump_DDSCAPS, ddsCaps)
    };
    static const struct member_info members_caps2[] =
    {
        ME(DDSD_CAPS, DDRAW_dump_DDSCAPS2, ddsCaps)
    };
#undef STRUCT
 
    if (NULL == lpddsd)
    {
        TRACE("(null)\n");
    }
    else
    {
      if (lpddsd->dwSize >= sizeof(DDSURFACEDESC2))
      {
          DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members_caps2, 1);
      }
      else
      {
          DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members_caps, 1);
      }
      DDRAW_dump_members(lpddsd->dwFlags, lpddsd, members, ARRAY_SIZE(members));
    }
}

Referenced by ddraw2_CreateSurface(), ddraw4_CreateSurface(), ddraw7_CreateSurface(), ddraw7_GetDisplayMode(), ddraw_surface3_GetSurfaceDesc(), ddraw_surface7_GetSurfaceDesc(), ddraw_surface_create(), and surface_lock().

ddraw_find_decl()

struct wined3d_vertex_declaration * ddraw_find_decl	(	struct ddraw *	ddraw,
		DWORD	fvf
	)

Definition at line 4797 of file ddraw.c.

{
    struct wined3d_vertex_declaration *pDecl = NULL;
    HRESULT hr;
    int p, low, high; /* deliberately signed */
    struct FvfToDecl *convertedDecls = This->decls;
 
    TRACE("Searching for declaration for fvf %08x... ", fvf);
 
    low = 0;
    high = This->numConvertedDecls - 1;
    while(low <= high) {
        p = (low + high) >> 1;
        TRACE("%d ", p);
        if(convertedDecls[p].fvf == fvf) {
            TRACE("found %p\n", convertedDecls[p].decl);
            return convertedDecls[p].decl;
        } else if(convertedDecls[p].fvf < fvf) {
            low = p + 1;
        } else {
            high = p - 1;
        }
    }
    TRACE("not found. Creating and inserting at position %d.\n", low);
 
    hr = wined3d_vertex_declaration_create_from_fvf(This->wined3d_device,
            fvf, This, &ddraw_null_wined3d_parent_ops, &pDecl);
    if (hr != S_OK) return NULL;
 
    if (This->declArraySize == This->numConvertedDecls)
    {
        unsigned int grow = max(This->declArraySize / 2, 8);
 
        if (!(convertedDecls = heap_realloc(convertedDecls,
                (This->numConvertedDecls + grow) * sizeof(*convertedDecls))))
        {
            wined3d_vertex_declaration_decref(pDecl);
            return NULL;
        }
        This->decls = convertedDecls;
        This->declArraySize += grow;
    }
 
    memmove(convertedDecls + low + 1, convertedDecls + low, sizeof(convertedDecls[0]) * (This->numConvertedDecls - low));
    convertedDecls[low].decl = pDecl;
    convertedDecls[low].fvf = fvf;
    This->numConvertedDecls++;
 
    TRACE("Returning %p. %d decls in array\n", pDecl, This->numConvertedDecls);
    return pDecl;
}

Referenced by d3d_device7_DrawIndexedPrimitive(), d3d_device7_DrawIndexedPrimitiveStrided(), d3d_device7_DrawPrimitive(), d3d_device7_DrawPrimitiveStrided(), and d3d_vertex_buffer_create().

ddraw_free_handle()

void * ddraw_free_handle	(	struct ddraw_handle_table *	t,
		DWORD	handle,
		enum ddraw_handle_type	type
	)

Definition at line 156 of file main.c.

{
    struct ddraw_handle_entry *entry;
    void *object;
 
    if (handle == DDRAW_INVALID_HANDLE || handle >= t->entry_count)
    {
        WARN("Invalid handle %#x passed.\n", handle);
        return NULL;
    }
 
    entry = &t->entries[handle];
    if (entry->type != type)
    {
        WARN("Handle %#x (%p) is not of type %#x.\n", handle, entry->object, type);
        return NULL;
    }
 
    object = entry->object;
    entry->object = t->free_entries;
    entry->type = DDRAW_HANDLE_FREE;
    t->free_entries = entry;
 
    return object;
}

Referenced by d3d_device1_DeleteMatrix(), d3d_device7_DeleteStateBlock(), d3d_material3_Release(), and ddraw_surface_wined3d_object_destroyed().

ddraw_get_d3dcaps()

HRESULT ddraw_get_d3dcaps	(	const struct ddraw *	ddraw,
		D3DDEVICEDESC7 *	caps
	)

Definition at line 1248 of file ddraw.c.

{
    WINED3DCAPS wined3d_caps;
    HRESULT hr;
 
    TRACE("ddraw %p, caps %p.\n", ddraw, caps);
 
    memset(&wined3d_caps, 0, sizeof(wined3d_caps));
 
    wined3d_mutex_lock();
    hr = wined3d_get_device_caps(ddraw->wined3d, 0, WINED3D_DEVICE_TYPE_HAL, &wined3d_caps);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to get device caps, hr %#x.\n", hr);
        return hr;
    }
 
    caps->dwDevCaps = wined3d_caps.DevCaps;
    caps->dpcLineCaps.dwMiscCaps = wined3d_caps.PrimitiveMiscCaps;
    caps->dpcLineCaps.dwRasterCaps = wined3d_caps.RasterCaps;
    caps->dpcLineCaps.dwZCmpCaps = wined3d_caps.ZCmpCaps;
    caps->dpcLineCaps.dwSrcBlendCaps = wined3d_caps.SrcBlendCaps;
    caps->dpcLineCaps.dwDestBlendCaps = wined3d_caps.DestBlendCaps;
    caps->dpcLineCaps.dwAlphaCmpCaps = wined3d_caps.AlphaCmpCaps;
    caps->dpcLineCaps.dwShadeCaps = wined3d_caps.ShadeCaps;
    caps->dpcLineCaps.dwTextureCaps = wined3d_caps.TextureCaps;
    caps->dpcLineCaps.dwTextureFilterCaps = wined3d_caps.TextureFilterCaps;
    caps->dpcLineCaps.dwTextureAddressCaps = wined3d_caps.TextureAddressCaps;
 
    caps->dwMaxTextureWidth = wined3d_caps.MaxTextureWidth;
    caps->dwMaxTextureHeight = wined3d_caps.MaxTextureHeight;
 
    caps->dwMaxTextureRepeat = wined3d_caps.MaxTextureRepeat;
    caps->dwMaxTextureAspectRatio = wined3d_caps.MaxTextureAspectRatio;
    caps->dwMaxAnisotropy = wined3d_caps.MaxAnisotropy;
    caps->dvMaxVertexW = wined3d_caps.MaxVertexW;
 
    caps->dvGuardBandLeft = wined3d_caps.GuardBandLeft;
    caps->dvGuardBandTop = wined3d_caps.GuardBandTop;
    caps->dvGuardBandRight = wined3d_caps.GuardBandRight;
    caps->dvGuardBandBottom = wined3d_caps.GuardBandBottom;
 
    caps->dvExtentsAdjust = wined3d_caps.ExtentsAdjust;
    caps->dwStencilCaps = wined3d_caps.StencilCaps;
 
    caps->dwFVFCaps = wined3d_caps.FVFCaps;
    caps->dwTextureOpCaps = wined3d_caps.TextureOpCaps;
 
    caps->dwVertexProcessingCaps = wined3d_caps.VertexProcessingCaps;
    caps->dwMaxActiveLights = wined3d_caps.MaxActiveLights;
 
    /* Remove all non-d3d7 caps */
    caps->dwDevCaps &= (
        D3DDEVCAPS_FLOATTLVERTEX         | D3DDEVCAPS_SORTINCREASINGZ          | D3DDEVCAPS_SORTDECREASINGZ          |
        D3DDEVCAPS_SORTEXACT             | D3DDEVCAPS_EXECUTESYSTEMMEMORY      | D3DDEVCAPS_EXECUTEVIDEOMEMORY       |
        D3DDEVCAPS_TLVERTEXSYSTEMMEMORY  | D3DDEVCAPS_TLVERTEXVIDEOMEMORY      | D3DDEVCAPS_TEXTURESYSTEMMEMORY      |
        D3DDEVCAPS_TEXTUREVIDEOMEMORY    | D3DDEVCAPS_DRAWPRIMTLVERTEX         | D3DDEVCAPS_CANRENDERAFTERFLIP       |
        D3DDEVCAPS_TEXTURENONLOCALVIDMEM | D3DDEVCAPS_DRAWPRIMITIVES2          | D3DDEVCAPS_SEPARATETEXTUREMEMORIES  |
        D3DDEVCAPS_DRAWPRIMITIVES2EX     | D3DDEVCAPS_HWTRANSFORMANDLIGHT      | D3DDEVCAPS_CANBLTSYSTONONLOCAL      |
        D3DDEVCAPS_HWRASTERIZATION);
 
    caps->dwStencilCaps &= (
        D3DSTENCILCAPS_KEEP              | D3DSTENCILCAPS_ZERO                 | D3DSTENCILCAPS_REPLACE              |
        D3DSTENCILCAPS_INCRSAT           | D3DSTENCILCAPS_DECRSAT              | D3DSTENCILCAPS_INVERT               |
        D3DSTENCILCAPS_INCR              | D3DSTENCILCAPS_DECR);
 
    /* FVF caps ?*/
 
    caps->dwTextureOpCaps &= (
        D3DTEXOPCAPS_DISABLE             | D3DTEXOPCAPS_SELECTARG1             | D3DTEXOPCAPS_SELECTARG2             |
        D3DTEXOPCAPS_MODULATE            | D3DTEXOPCAPS_MODULATE2X             | D3DTEXOPCAPS_MODULATE4X             |
        D3DTEXOPCAPS_ADD                 | D3DTEXOPCAPS_ADDSIGNED              | D3DTEXOPCAPS_ADDSIGNED2X            |
        D3DTEXOPCAPS_SUBTRACT            | D3DTEXOPCAPS_ADDSMOOTH              | D3DTEXOPCAPS_BLENDTEXTUREALPHA      |
        D3DTEXOPCAPS_BLENDFACTORALPHA    | D3DTEXOPCAPS_BLENDTEXTUREALPHAPM    | D3DTEXOPCAPS_BLENDCURRENTALPHA      |
        D3DTEXOPCAPS_PREMODULATE         | D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
        D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR | D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA | D3DTEXOPCAPS_BUMPENVMAP    |
        D3DTEXOPCAPS_BUMPENVMAPLUMINANCE | D3DTEXOPCAPS_DOTPRODUCT3);
 
    caps->dwVertexProcessingCaps &= (
        D3DVTXPCAPS_TEXGEN               | D3DVTXPCAPS_MATERIALSOURCE7         | D3DVTXPCAPS_VERTEXFOG               |
        D3DVTXPCAPS_DIRECTIONALLIGHTS    | D3DVTXPCAPS_POSITIONALLIGHTS        | D3DVTXPCAPS_LOCALVIEWER);
 
    caps->dpcLineCaps.dwMiscCaps &= (
        D3DPMISCCAPS_MASKPLANES          | D3DPMISCCAPS_MASKZ                  | D3DPMISCCAPS_LINEPATTERNREP         |
        D3DPMISCCAPS_CONFORMANT          | D3DPMISCCAPS_CULLNONE               | D3DPMISCCAPS_CULLCW                 |
        D3DPMISCCAPS_CULLCCW);
 
    caps->dpcLineCaps.dwRasterCaps &= (
        D3DPRASTERCAPS_DITHER            | D3DPRASTERCAPS_ROP2                 | D3DPRASTERCAPS_XOR                  |
        D3DPRASTERCAPS_PAT               | D3DPRASTERCAPS_ZTEST                | D3DPRASTERCAPS_SUBPIXEL             |
        D3DPRASTERCAPS_SUBPIXELX         | D3DPRASTERCAPS_FOGVERTEX            | D3DPRASTERCAPS_FOGTABLE             |
        D3DPRASTERCAPS_STIPPLE           | D3DPRASTERCAPS_ANTIALIASSORTDEPENDENT | D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT |
        D3DPRASTERCAPS_ANTIALIASEDGES    | D3DPRASTERCAPS_MIPMAPLODBIAS        | D3DPRASTERCAPS_ZBIAS                |
        D3DPRASTERCAPS_ZBUFFERLESSHSR    | D3DPRASTERCAPS_FOGRANGE             | D3DPRASTERCAPS_ANISOTROPY           |
        D3DPRASTERCAPS_WBUFFER           | D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT | D3DPRASTERCAPS_WFOG           |
        D3DPRASTERCAPS_ZFOG);
 
    caps->dpcLineCaps.dwZCmpCaps &= (
        D3DPCMPCAPS_NEVER                | D3DPCMPCAPS_LESS                    | D3DPCMPCAPS_EQUAL                   |
        D3DPCMPCAPS_LESSEQUAL            | D3DPCMPCAPS_GREATER                 | D3DPCMPCAPS_NOTEQUAL                |
        D3DPCMPCAPS_GREATEREQUAL         | D3DPCMPCAPS_ALWAYS);
 
    caps->dpcLineCaps.dwSrcBlendCaps &= (
        D3DPBLENDCAPS_ZERO               | D3DPBLENDCAPS_ONE                   | D3DPBLENDCAPS_SRCCOLOR              |
        D3DPBLENDCAPS_INVSRCCOLOR        | D3DPBLENDCAPS_SRCALPHA              | D3DPBLENDCAPS_INVSRCALPHA           |
        D3DPBLENDCAPS_DESTALPHA          | D3DPBLENDCAPS_INVDESTALPHA          | D3DPBLENDCAPS_DESTCOLOR             |
        D3DPBLENDCAPS_INVDESTCOLOR       | D3DPBLENDCAPS_SRCALPHASAT           | D3DPBLENDCAPS_BOTHSRCALPHA          |
        D3DPBLENDCAPS_BOTHINVSRCALPHA);
 
    caps->dpcLineCaps.dwDestBlendCaps &= (
        D3DPBLENDCAPS_ZERO               | D3DPBLENDCAPS_ONE                   | D3DPBLENDCAPS_SRCCOLOR              |
        D3DPBLENDCAPS_INVSRCCOLOR        | D3DPBLENDCAPS_SRCALPHA              | D3DPBLENDCAPS_INVSRCALPHA           |
        D3DPBLENDCAPS_DESTALPHA          | D3DPBLENDCAPS_INVDESTALPHA          | D3DPBLENDCAPS_DESTCOLOR             |
        D3DPBLENDCAPS_INVDESTCOLOR       | D3DPBLENDCAPS_SRCALPHASAT           | D3DPBLENDCAPS_BOTHSRCALPHA          |
        D3DPBLENDCAPS_BOTHINVSRCALPHA);
 
    caps->dpcLineCaps.dwAlphaCmpCaps &= (
        D3DPCMPCAPS_NEVER                | D3DPCMPCAPS_LESS                    | D3DPCMPCAPS_EQUAL                   |
        D3DPCMPCAPS_LESSEQUAL            | D3DPCMPCAPS_GREATER                 | D3DPCMPCAPS_NOTEQUAL                |
        D3DPCMPCAPS_GREATEREQUAL         | D3DPCMPCAPS_ALWAYS);
 
    caps->dpcLineCaps.dwShadeCaps &= (
        D3DPSHADECAPS_COLORFLATMONO      | D3DPSHADECAPS_COLORFLATRGB          | D3DPSHADECAPS_COLORGOURAUDMONO      |
        D3DPSHADECAPS_COLORGOURAUDRGB    | D3DPSHADECAPS_COLORPHONGMONO        | D3DPSHADECAPS_COLORPHONGRGB         |
        D3DPSHADECAPS_SPECULARFLATMONO   | D3DPSHADECAPS_SPECULARFLATRGB       | D3DPSHADECAPS_SPECULARGOURAUDMONO   |
        D3DPSHADECAPS_SPECULARGOURAUDRGB | D3DPSHADECAPS_SPECULARPHONGMONO     | D3DPSHADECAPS_SPECULARPHONGRGB      |
        D3DPSHADECAPS_ALPHAFLATBLEND     | D3DPSHADECAPS_ALPHAFLATSTIPPLED     | D3DPSHADECAPS_ALPHAGOURAUDBLEND     |
        D3DPSHADECAPS_ALPHAGOURAUDSTIPPLED | D3DPSHADECAPS_ALPHAPHONGBLEND     | D3DPSHADECAPS_ALPHAPHONGSTIPPLED    |
        D3DPSHADECAPS_FOGFLAT            | D3DPSHADECAPS_FOGGOURAUD            | D3DPSHADECAPS_FOGPHONG);
 
    caps->dpcLineCaps.dwTextureCaps &= (
        D3DPTEXTURECAPS_PERSPECTIVE      | D3DPTEXTURECAPS_POW2                | D3DPTEXTURECAPS_ALPHA               |
        D3DPTEXTURECAPS_TRANSPARENCY     | D3DPTEXTURECAPS_BORDER              | D3DPTEXTURECAPS_SQUAREONLY          |
        D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE | D3DPTEXTURECAPS_ALPHAPALETTE| D3DPTEXTURECAPS_NONPOW2CONDITIONAL  |
        D3DPTEXTURECAPS_PROJECTED        | D3DPTEXTURECAPS_CUBEMAP             | D3DPTEXTURECAPS_COLORKEYBLEND);
 
    caps->dpcLineCaps.dwTextureFilterCaps &= (
        D3DPTFILTERCAPS_NEAREST          | D3DPTFILTERCAPS_LINEAR              | D3DPTFILTERCAPS_MIPNEAREST          |
        D3DPTFILTERCAPS_MIPLINEAR        | D3DPTFILTERCAPS_LINEARMIPNEAREST    | D3DPTFILTERCAPS_LINEARMIPLINEAR     |
        D3DPTFILTERCAPS_MINFPOINT        | D3DPTFILTERCAPS_MINFLINEAR          | D3DPTFILTERCAPS_MINFANISOTROPIC     |
        D3DPTFILTERCAPS_MIPFPOINT        | D3DPTFILTERCAPS_MIPFLINEAR          | D3DPTFILTERCAPS_MAGFPOINT           |
        D3DPTFILTERCAPS_MAGFLINEAR       | D3DPTFILTERCAPS_MAGFANISOTROPIC     | D3DPTFILTERCAPS_MAGFAFLATCUBIC      |
        D3DPTFILTERCAPS_MAGFGAUSSIANCUBIC);
 
    caps->dpcLineCaps.dwTextureAddressCaps &= (
        D3DPTADDRESSCAPS_WRAP            | D3DPTADDRESSCAPS_MIRROR             | D3DPTADDRESSCAPS_CLAMP              |
        D3DPTADDRESSCAPS_BORDER          | D3DPTADDRESSCAPS_INDEPENDENTUV);
 
    if (!(caps->dpcLineCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2))
    {
        /* DirectX7 always has the np2 flag set, no matter what the card
         * supports. Some old games (Rollcage) check the caps incorrectly.
         * If wined3d supports nonpow2 textures it also has np2 conditional
         * support. */
        caps->dpcLineCaps.dwTextureCaps |= D3DPTEXTURECAPS_POW2 | D3DPTEXTURECAPS_NONPOW2CONDITIONAL;
    }
 
    /* Fill the missing members, and do some fixup */
    caps->dpcLineCaps.dwSize = sizeof(caps->dpcLineCaps);
    caps->dpcLineCaps.dwTextureBlendCaps = D3DPTBLENDCAPS_ADD
            | D3DPTBLENDCAPS_MODULATEMASK
            | D3DPTBLENDCAPS_COPY
            | D3DPTBLENDCAPS_DECAL
            | D3DPTBLENDCAPS_DECALALPHA
            | D3DPTBLENDCAPS_DECALMASK
            | D3DPTBLENDCAPS_MODULATE
            | D3DPTBLENDCAPS_MODULATEALPHA;
    caps->dpcLineCaps.dwStippleWidth = 32;
    caps->dpcLineCaps.dwStippleHeight = 32;
    /* Use the same for the TriCaps */
    caps->dpcTriCaps = caps->dpcLineCaps;
 
    caps->dwDeviceRenderBitDepth = DDBD_16 | DDBD_24 | DDBD_32;
    caps->dwDeviceZBufferBitDepth = DDBD_16 | DDBD_24;
    caps->dwMinTextureWidth = 1;
    caps->dwMinTextureHeight = 1;
 
    /* Convert DWORDs safely to WORDs */
    caps->wMaxTextureBlendStages = min(wined3d_caps.MaxTextureBlendStages, 0xffff);
    caps->wMaxSimultaneousTextures = min(wined3d_caps.MaxSimultaneousTextures, 0xffff);
    caps->wMaxUserClipPlanes = min(wined3d_caps.MaxUserClipPlanes, D3DMAXUSERCLIPPLANES);
    caps->wMaxVertexBlendMatrices = min(wined3d_caps.MaxVertexBlendMatrices, 0xffff);
 
    caps->deviceGUID = IID_IDirect3DTnLHalDevice;
 
    caps->dwReserved1 = 0;
    caps->dwReserved2 = 0;
    caps->dwReserved3 = 0;
    caps->dwReserved4 = 0;
 
    return DD_OK;
}

Referenced by d3d3_EnumDevices(), d3d3_FindDevice(), d3d7_EnumDevices(), d3d_device3_GetCaps(), and d3d_device7_GetCaps().

ddraw_get_object()

void * ddraw_get_object	(	struct ddraw_handle_table *	t,
		DWORD	handle,
		enum ddraw_handle_type	type
	)

Definition at line 182 of file main.c.

{
    struct ddraw_handle_entry *entry;
 
    if (handle == DDRAW_INVALID_HANDLE || handle >= t->entry_count)
    {
        WARN("Invalid handle %#x passed.\n", handle);
        return NULL;
    }
 
    entry = &t->entries[handle];
    if (entry->type != type)
    {
        WARN("Handle %#x (%p) is not of type %#x.\n", handle, entry->object, type);
        return NULL;
    }
 
    return entry->object;
}

Referenced by d3d_device1_GetMatrix(), d3d_device1_SetMatrix(), d3d_device3_SetLightState(), d3d_device3_SetRenderState(), d3d_device7_ApplyStateBlock(), d3d_device7_CaptureStateBlock(), and d3d_viewport_SetBackground().

ddraw_handle_table_destroy()

void ddraw_handle_table_destroy

(

struct ddraw_handle_table *

t

)

Definition at line 107 of file main.c.

{
    heap_free(t->entries);
    memset(t, 0, sizeof(*t));
}

Referenced by d3d_device_init(), and d3d_device_inner_Release().

ddraw_handle_table_init()

BOOL ddraw_handle_table_init	(	struct ddraw_handle_table *	t,
		UINT	initial_size
	)

Definition at line 93 of file main.c.

{
    if (!(t->entries = heap_alloc_zero(initial_size * sizeof(*t->entries))))
    {
        ERR("Failed to allocate handle table memory.\n");
        return FALSE;
    }
    t->free_entries = NULL;
    t->table_size = initial_size;
    t->entry_count = 0;
 
    return TRUE;
}

Referenced by d3d_device_init().

ddraw_init()

HRESULT ddraw_init	(	struct ddraw *	ddraw,
		DWORD	flags,
		enum wined3d_device_type	device_type
	)

Definition at line 5048 of file ddraw.c.

{
    WINED3DCAPS caps;
    HRESULT hr;
 
    ddraw->IDirectDraw7_iface.lpVtbl = &ddraw7_vtbl;
    ddraw->IDirectDraw_iface.lpVtbl = &ddraw1_vtbl;
    ddraw->IDirectDraw2_iface.lpVtbl = &ddraw2_vtbl;
    ddraw->IDirectDraw4_iface.lpVtbl = &ddraw4_vtbl;
    ddraw->IDirect3D_iface.lpVtbl = &d3d1_vtbl;
    ddraw->IDirect3D2_iface.lpVtbl = &d3d2_vtbl;
    ddraw->IDirect3D3_iface.lpVtbl = &d3d3_vtbl;
    ddraw->IDirect3D7_iface.lpVtbl = &d3d7_vtbl;
    ddraw->device_parent.ops = &ddraw_wined3d_device_parent_ops;
    ddraw->numIfaces = 1;
    ddraw->ref7 = 1;
 
    flags |= DDRAW_WINED3D_FLAGS;
    if (!(ddraw->wined3d = wined3d_create(flags)))
    {
        flags |= WINED3D_NO3D;
        if (!(ddraw->wined3d = wined3d_create(flags)))
        {
            WARN("Failed to create a wined3d object.\n");
            return E_FAIL;
        }
    }
 
    if (FAILED(hr = wined3d_get_device_caps(ddraw->wined3d, WINED3DADAPTER_DEFAULT, device_type, &caps)))
    {
        ERR("Failed to get device caps, hr %#x.\n", hr);
        wined3d_decref(ddraw->wined3d);
        return E_FAIL;
    }
 
    if (!(caps.ddraw_caps.caps & WINEDDCAPS_3D))
    {
        WARN("Created a wined3d object without 3D support.\n");
        ddraw->flags |= DDRAW_NO3D;
    }
 
    if (FAILED(hr = wined3d_device_create(ddraw->wined3d, WINED3DADAPTER_DEFAULT, device_type,
            NULL, 0, DDRAW_STRIDE_ALIGNMENT, &ddraw->device_parent, &ddraw->wined3d_device)))
    {
        WARN("Failed to create a wined3d device, hr %#x.\n", hr);
        wined3d_decref(ddraw->wined3d);
        return hr;
    }
 
    list_init(&ddraw->surface_list);
 
    return DD_OK;
}

Referenced by DDRAW_Create().

ddraw_palette_init()

HRESULT ddraw_palette_init	(	struct ddraw_palette *	palette,
		struct ddraw *	ddraw,
		DWORD	flags,
		PALETTEENTRY *	entries
	)

Definition at line 258 of file palette.c.

{
    unsigned int entry_count;
    DWORD wined3d_flags = 0;
    HRESULT hr;
 
    if ((entry_count = palette_size(flags)) == ~0u)
    {
        WARN("Invalid flags %#x.\n", flags);
        return DDERR_INVALIDPARAMS;
    }
 
    if (flags & DDPCAPS_8BITENTRIES)
        wined3d_flags |= WINED3D_PALETTE_8BIT_ENTRIES;
    if (flags & DDPCAPS_ALLOW256)
        wined3d_flags |= WINED3D_PALETTE_ALLOW_256;
    if (flags & DDPCAPS_ALPHA)
        wined3d_flags |= WINED3D_PALETTE_ALPHA;
 
    palette->IDirectDrawPalette_iface.lpVtbl = &ddraw_palette_vtbl;
    palette->ref = 1;
    palette->flags = flags;
 
    if (FAILED(hr = wined3d_palette_create(ddraw->wined3d_device,
            wined3d_flags, entry_count, entries, &palette->wined3d_palette)))
    {
        WARN("Failed to create wined3d palette, hr %#x.\n", hr);
        return hr;
    }
 
    palette->ddraw = ddraw;
    palette->ifaceToRelease = (IUnknown *)&ddraw->IDirectDraw7_iface;
    IUnknown_AddRef(palette->ifaceToRelease);
 
    return DD_OK;
}

Referenced by ddraw7_CreatePalette().

ddraw_set_swapchain_window()

static void ddraw_set_swapchain_window ( struct ddraw *  ddraw, HWND  window  )

inlinestatic

Definition at line 135 of file ddraw_private.h.

{
    if (window == GetDesktopWindow())
        window = NULL;
    ddraw->swapchain_window = window;
}

Referenced by ddraw_create_swapchain(), ddraw_destroy_swapchain(), and ddraw_surface7_SetClipper().

ddraw_surface_create()

HRESULT ddraw_surface_create	(	struct ddraw *	ddraw,
		const DDSURFACEDESC2 *	surface_desc,
		struct ddraw_surface **	surface,
		IUnknown *	outer_unknown,
		unsigned int	version
	)

Definition at line 5791 of file surface.c.

{
    struct wined3d_sub_resource_desc wined3d_mip_desc;
    struct ddraw_surface *root, *mip, **attach;
    struct wined3d_resource_desc wined3d_desc;
    struct wined3d_texture *wined3d_texture;
    struct wined3d_display_mode mode;
    DDSURFACEDESC2 *desc, *mip_desc;
    struct ddraw_texture *texture;
    unsigned int layers = 1;
    unsigned int pitch = 0;
    UINT levels, i, j;
    HRESULT hr;
 
    TRACE("ddraw %p, surface_desc %p, surface %p, outer_unknown %p, version %u.\n",
            ddraw, surface_desc, surface, outer_unknown, version);
    if (TRACE_ON(ddraw))
    {
        TRACE("Requesting surface desc:\n");
        DDRAW_dump_surface_desc(surface_desc);
    }
 
    if (outer_unknown)
        return CLASS_E_NOAGGREGATION;
 
    if (!surface)
        return E_POINTER;
 
    if (!(texture = heap_alloc(sizeof(*texture))))
        return E_OUTOFMEMORY;
 
    texture->version = version;
    texture->surface_desc = *surface_desc;
    desc = &texture->surface_desc;
 
    /* Ensure DDSD_CAPS is always set. */
    desc->dwFlags |= DDSD_CAPS;
 
    if (desc->ddsCaps.dwCaps & DDSCAPS_FLIP)
    {
        if (!(desc->dwFlags & DDSD_BACKBUFFERCOUNT) || !desc->u5.dwBackBufferCount)
        {
            WARN("Tried to create a flippable surface without any back buffers.\n");
            heap_free(texture);
            return DDERR_INVALIDCAPS;
        }
 
        if (!(desc->ddsCaps.dwCaps & DDSCAPS_COMPLEX))
        {
            WARN("Tried to create a flippable surface without DDSCAPS_COMPLEX.\n");
            heap_free(texture);
            return DDERR_INVALIDCAPS;
        }
 
        if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
        {
            WARN("Tried to create a flippable cubemap.\n");
            heap_free(texture);
            return DDERR_INVALIDPARAMS;
        }
 
        if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
        {
            FIXME("Flippable textures not implemented.\n");
            heap_free(texture);
            return DDERR_INVALIDCAPS;
        }
    }
    else
    {
        if (desc->dwFlags & DDSD_BACKBUFFERCOUNT)
        {
            WARN("Tried to specify a back buffer count for a non-flippable surface.\n");
            hr = desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP ? DDERR_INVALIDPARAMS : DDERR_INVALIDCAPS;
            heap_free(texture);
            return hr;
        }
    }
 
    if (desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    {
        if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
        {
            WARN("Tried to create a primary surface with DDSCAPS_TEXTURE.\n");
            heap_free(texture);
            return DDERR_INVALIDCAPS;
        }
 
        if ((desc->ddsCaps.dwCaps & DDSCAPS_COMPLEX) && !(desc->ddsCaps.dwCaps & DDSCAPS_FLIP))
        {
            WARN("Tried to create a flippable primary surface without both DDSCAPS_FLIP and DDSCAPS_COMPLEX.\n");
            heap_free(texture);
            return DDERR_INVALIDCAPS;
        }
 
        if ((desc->ddsCaps.dwCaps & DDSCAPS_FLIP) && !(ddraw->cooperative_level & DDSCL_EXCLUSIVE))
        {
            WARN("Tried to create a flippable primary surface without DDSCL_EXCLUSIVE.\n");
            heap_free(texture);
            return DDERR_NOEXCLUSIVEMODE;
        }
    }
 
    /* This is a special case in ddrawex, but not allowed in ddraw. */
    if ((desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
            == (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
    {
        WARN("Tried to create a surface in both system and video memory.\n");
        heap_free(texture);
        return DDERR_INVALIDCAPS;
    }
 
    if ((desc->ddsCaps.dwCaps & (DDSCAPS_ALLOCONLOAD | DDSCAPS_MIPMAP))
            && !(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
    {
        WARN("Caps %#x require DDSCAPS_TEXTURE.\n", desc->ddsCaps.dwCaps);
        heap_free(texture);
        return DDERR_INVALIDCAPS;
    }
 
    if ((desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES)
            && !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
    {
        WARN("Cube map faces requested without cube map flag.\n");
        heap_free(texture);
        return DDERR_INVALIDCAPS;
    }
 
    if ((desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
            && !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES))
    {
        WARN("Cube map without faces requested.\n");
        heap_free(texture);
        return DDERR_INVALIDPARAMS;
    }
 
    if ((desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
            && (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES) != DDSCAPS2_CUBEMAP_ALLFACES)
        FIXME("Partial cube maps not implemented.\n");
 
    if (desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE))
    {
        if (!(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
        {
            WARN("DDSCAPS2_TEXTUREMANAGE used without DDSCAPS_TEXTURE, returning DDERR_INVALIDCAPS.\n");
            heap_free(texture);
            return DDERR_INVALIDCAPS;
        }
        if (desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
        {
            WARN("DDSCAPS2_TEXTUREMANAGE used width DDSCAPS_VIDEOMEMORY "
                    "or DDSCAPS_SYSTEMMEMORY, returning DDERR_INVALIDCAPS.\n");
            heap_free(texture);
            return DDERR_INVALIDCAPS;
        }
    }
 
    if (FAILED(hr = wined3d_get_adapter_display_mode(ddraw->wined3d, WINED3DADAPTER_DEFAULT, &mode, NULL)))
    {
        ERR("Failed to get display mode, hr %#x.\n", hr);
        heap_free(texture);
        return hr_ddraw_from_wined3d(hr);
    }
 
    /* No pixelformat given? Use the current screen format. */
    if (!(desc->dwFlags & DDSD_PIXELFORMAT))
    {
        desc->dwFlags |= DDSD_PIXELFORMAT;
        desc->u4.ddpfPixelFormat.dwSize = sizeof(desc->u4.ddpfPixelFormat);
        ddrawformat_from_wined3dformat(&desc->u4.ddpfPixelFormat, mode.format_id);
    }
 
    wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE_2D;
    wined3d_desc.format = wined3dformat_from_ddrawformat(&desc->u4.ddpfPixelFormat);
    if (wined3d_desc.format == WINED3DFMT_UNKNOWN)
    {
        WARN("Unsupported / unknown pixelformat.\n");
        heap_free(texture);
        return DDERR_INVALIDPIXELFORMAT;
    }
 
    /* No width or no height? Use the screen size. */
    if (!(desc->dwFlags & DDSD_WIDTH) || !(desc->dwFlags & DDSD_HEIGHT))
    {
        if (!(desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
        {
            WARN("No width / height specified.\n");
            heap_free(texture);
            return DDERR_INVALIDPARAMS;
        }
 
        desc->dwFlags |= DDSD_WIDTH | DDSD_HEIGHT;
        desc->dwWidth = mode.width;
        desc->dwHeight = mode.height;
    }
 
    if (!desc->dwWidth || !desc->dwHeight)
    {
        heap_free(texture);
        return DDERR_INVALIDPARAMS;
    }
 
    if (desc->ddsCaps.dwCaps & DDSCAPS_FLIP)
        desc->ddsCaps.dwCaps |= DDSCAPS_FRONTBUFFER;
 
    if (desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    {
        /* The first surface is a front buffer, the back buffers are created
         * afterwards. */
        desc->ddsCaps.dwCaps |= DDSCAPS_VISIBLE;
        if (ddraw->cooperative_level & DDSCL_EXCLUSIVE)
        {
            struct wined3d_swapchain_desc swapchain_desc;
 
            wined3d_swapchain_get_desc(ddraw->wined3d_swapchain, &swapchain_desc);
            swapchain_desc.backbuffer_width = mode.width;
            swapchain_desc.backbuffer_height = mode.height;
            swapchain_desc.backbuffer_format = mode.format_id;
 
            if (FAILED(hr = wined3d_device_reset(ddraw->wined3d_device,
                    &swapchain_desc, NULL, ddraw_reset_enum_callback, TRUE)))
            {
                ERR("Failed to reset device.\n");
                heap_free(texture);
                return hr_ddraw_from_wined3d(hr);
            }
 
            wined3d_device_set_render_state(ddraw->wined3d_device, WINED3D_RS_ZENABLE,
                    !!swapchain_desc.enable_auto_depth_stencil);
        }
    }
 
    wined3d_desc.multisample_type = WINED3D_MULTISAMPLE_NONE;
    wined3d_desc.multisample_quality = 0;
    wined3d_desc.usage = 0;
    wined3d_desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
    wined3d_desc.width = desc->dwWidth;
    wined3d_desc.height = desc->dwHeight;
    wined3d_desc.depth = 1;
    wined3d_desc.size = 0;
 
    if ((desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE) && (ddraw->flags & DDRAW_NO3D))
    {
        WARN("The application requests a 3D capable surface, but the ddraw object was created without 3D support.\n");
        /* Do not fail surface creation, only fail 3D device creation. */
    }
 
    /* Mipmap count fixes */
    if (desc->ddsCaps.dwCaps & DDSCAPS_MIPMAP)
    {
        if (desc->ddsCaps.dwCaps & DDSCAPS_COMPLEX)
        {
            if (desc->dwFlags & DDSD_MIPMAPCOUNT)
            {
                /* Mipmap count is given, should not be 0. */
                if (!desc->u2.dwMipMapCount)
                {
                    heap_free(texture);
                    return DDERR_INVALIDPARAMS;
                }
            }
            else
            {
                /* Undocumented feature: Create sublevels until either the
                 * width or the height is 1. */
                if (version == 7)
                    desc->u2.dwMipMapCount = wined3d_log2i(max(desc->dwWidth, desc->dwHeight)) + 1;
                else
                    desc->u2.dwMipMapCount = wined3d_log2i(min(desc->dwWidth, desc->dwHeight)) + 1;
            }
        }
        else
        {
            desc->u2.dwMipMapCount = 1;
        }
 
        desc->dwFlags |= DDSD_MIPMAPCOUNT;
        levels = desc->u2.dwMipMapCount;
    }
    else
    {
        levels = 1;
    }
 
    if (!(desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY)))
    {
        if (!(desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE)))
        {
            DWORD usage = 0;
 
            if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
                usage |= WINED3DUSAGE_LEGACY_CUBEMAP | WINED3DUSAGE_TEXTURE;
            else if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
                usage |= WINED3DUSAGE_TEXTURE;
 
            if (desc->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
                usage = WINED3DUSAGE_DEPTHSTENCIL;
            else if (desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
                usage = WINED3DUSAGE_RENDERTARGET;
 
            if (SUCCEEDED(hr = wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
                    WINED3D_DEVICE_TYPE_HAL, mode.format_id, usage, WINED3D_RTYPE_TEXTURE_2D, wined3d_desc.format)))
                desc->ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
            else
                desc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
        }
        else if (!(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
        {
            /* Tests show surfaces without memory flags get these flags added
             * right after creation. */
            desc->ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY;
        }
    }
 
    if ((desc->ddsCaps.dwCaps & (DDSCAPS_OVERLAY | DDSCAPS_SYSTEMMEMORY))
            == (DDSCAPS_OVERLAY | DDSCAPS_SYSTEMMEMORY))
    {
        WARN("System memory overlays are not allowed.\n");
        heap_free(texture);
        return DDERR_NOOVERLAYHW;
    }
 
    if (desc->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY)
    {
        /*
         * The ddraw RGB device allows to use system memory surfaces as rendering target.
         * This does not cause problems because the RGB device does software rasterization
         * though it will fail with hardware accelerated ddraw. In order to be partially
         * compatible with games requesting explicitly the RGB device, we ignore the
         * specified location and try to create rendering targets in video memory if
         * possible.
         */
        if ((desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE) &&
            SUCCEEDED(hr = wined3d_check_device_format(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
                        WINED3D_DEVICE_TYPE_HAL, mode.format_id, WINED3DUSAGE_RENDERTARGET,
                        WINED3D_RTYPE_TEXTURE_2D, wined3d_desc.format)))
        {
            FIXME("Application wants to create rendering target in system memory, using video memory instead\n");
            wined3d_desc.usage |= WINED3DUSAGE_RENDERTARGET;
        }
        else
            wined3d_desc.access = WINED3D_RESOURCE_ACCESS_CPU
                | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
    }
    else
    {
        if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
            wined3d_desc.usage |= WINED3DUSAGE_TEXTURE;
        if (desc->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
            wined3d_desc.usage |= WINED3DUSAGE_DEPTHSTENCIL;
        else if (desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
            wined3d_desc.usage |= WINED3DUSAGE_RENDERTARGET;
 
        if (desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE))
        {
            wined3d_desc.access = WINED3D_RESOURCE_ACCESS_GPU | WINED3D_RESOURCE_ACCESS_CPU
                    | WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
            /* Managed textures have the system memory flag set. */
            desc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
        }
        else if (desc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)
        {
            /* Videomemory adds localvidmem. This is mutually exclusive with
             * systemmemory and texturemanage. */
            desc->ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM;
            wined3d_desc.usage |= WINED3DUSAGE_DYNAMIC;
        }
    }
 
    if (desc->dwFlags & DDSD_LPSURFACE)
    {
        if (wined3d_desc.access & WINED3D_RESOURCE_ACCESS_GPU)
        {
            WARN("User memory surfaces should not be GPU accessible.\n");
            heap_free(texture);
            return DDERR_INVALIDCAPS;
        }
 
        if (version < 4)
        {
            WARN("User memory surfaces not supported before version 4.\n");
            heap_free(texture);
            return DDERR_INVALIDPARAMS;
        }
 
        if (!desc->lpSurface)
        {
            WARN("NULL surface memory pointer specified.\n");
            heap_free(texture);
            return DDERR_INVALIDPARAMS;
        }
 
        if (format_is_compressed(&desc->u4.ddpfPixelFormat))
        {
            if (version != 4 && (desc->dwFlags & DDSD_PITCH))
            {
                WARN("Pitch specified on a compressed user memory surface.\n");
                heap_free(texture);
                return DDERR_INVALIDPARAMS;
            }
 
            if (!(desc->dwFlags & (DDSD_LINEARSIZE | DDSD_PITCH)))
            {
                WARN("Compressed user memory surfaces should explicitly specify the linear size.\n");
                heap_free(texture);
                return DDERR_INVALIDPARAMS;
            }
 
            if ((desc->dwFlags & DDSD_LINEARSIZE)
                    && desc->u1.dwLinearSize < wined3d_calculate_format_pitch(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
                            wined3d_desc.format, wined3d_desc.width) * ((desc->dwHeight + 3) / 4))
            {
                WARN("Invalid linear size %u specified.\n", desc->u1.dwLinearSize);
                heap_free(texture);
                return DDERR_INVALIDPARAMS;
            }
        }
        else
        {
            if (!(desc->dwFlags & DDSD_PITCH))
            {
                WARN("User memory surfaces should explicitly specify the pitch.\n");
                heap_free(texture);
                return DDERR_INVALIDPARAMS;
            }
 
            if (desc->u1.lPitch < wined3d_calculate_format_pitch(ddraw->wined3d, WINED3DADAPTER_DEFAULT,
                    wined3d_desc.format, wined3d_desc.width) || desc->u1.lPitch & 3)
            {
                WARN("Invalid pitch %u specified.\n", desc->u1.lPitch);
                heap_free(texture);
                return DDERR_INVALIDPARAMS;
            }
 
            pitch = desc->u1.lPitch;
        }
    }
 
    if (((desc->dwFlags & DDSD_CKDESTOVERLAY)
            && desc->u3.ddckCKDestOverlay.dwColorSpaceLowValue != desc->u3.ddckCKDestOverlay.dwColorSpaceHighValue)
            || ((desc->dwFlags & DDSD_CKDESTBLT)
            && desc->ddckCKDestBlt.dwColorSpaceLowValue != desc->ddckCKDestBlt.dwColorSpaceHighValue)
            || ((desc->dwFlags & DDSD_CKSRCOVERLAY)
            && desc->ddckCKSrcOverlay.dwColorSpaceLowValue != desc->ddckCKSrcOverlay.dwColorSpaceHighValue)
            || ((desc->dwFlags & DDSD_CKSRCBLT)
            && desc->ddckCKSrcBlt.dwColorSpaceLowValue != desc->ddckCKSrcBlt.dwColorSpaceHighValue))
    {
        WARN("Range color keys not supported, returning DDERR_NOCOLORKEYHW.\n");
        heap_free(texture);
        return DDERR_NOCOLORKEYHW;
    }
 
    if (desc->ddsCaps.dwCaps & (DDSCAPS_OVERLAY))
        wined3d_desc.usage |= WINED3DUSAGE_OVERLAY;
 
    if (desc->ddsCaps.dwCaps & DDSCAPS_OWNDC)
        wined3d_desc.usage |= WINED3DUSAGE_OWNDC;
 
    if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
    {
        wined3d_desc.usage |= WINED3DUSAGE_LEGACY_CUBEMAP;
        layers = 6;
    }
 
    /* Some applications assume surfaces will always be mapped at the same
     * address. Some of those also assume that this address is valid even when
     * the surface isn't mapped, and that updates done this way will be
     * visible on the screen. The game Nox is such an application,
     * Commandos: Behind Enemy Lines is another. Setting
     * WINED3D_TEXTURE_CREATE_GET_DC_LENIENT will ensure this. */
    if (FAILED(hr = wined3d_texture_create(ddraw->wined3d_device, &wined3d_desc, layers, levels,
            WINED3D_TEXTURE_CREATE_GET_DC_LENIENT, NULL, texture,
            &ddraw_texture_wined3d_parent_ops, &wined3d_texture)))
    {
        WARN("Failed to create wined3d texture, hr %#x.\n", hr);
        heap_free(texture);
        return hr_ddraw_from_wined3d(hr);
    }
 
    root = wined3d_texture_get_sub_resource_parent(wined3d_texture, 0);
    wined3d_texture_decref(wined3d_texture);
    root->is_complex_root = TRUE;
    texture->root = root;
    wined3d_device_incref(texture->wined3d_device = ddraw->wined3d_device);
 
    if (desc->dwFlags & DDSD_CKDESTOVERLAY)
        wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTOVERLAY,
                (struct wined3d_color_key *)&desc->u3.ddckCKDestOverlay);
    if (desc->dwFlags & DDSD_CKDESTBLT)
        wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTBLT,
                (struct wined3d_color_key *)&desc->ddckCKDestBlt);
    if (desc->dwFlags & DDSD_CKSRCOVERLAY)
        wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCOVERLAY,
                (struct wined3d_color_key *)&desc->ddckCKSrcOverlay);
    if (desc->dwFlags & DDSD_CKSRCBLT)
        wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCBLT,
                (struct wined3d_color_key *)&desc->ddckCKSrcBlt);
 
    for (i = 0; i < layers; ++i)
    {
        attach = &root->complex_array[layers - 1 - i];
 
        for (j = 0; j < levels; ++j)
        {
            mip = wined3d_texture_get_sub_resource_parent(wined3d_texture, i * levels + j);
            mip_desc = &mip->surface_desc;
 
            if (j)
            {
                wined3d_texture_get_sub_resource_desc(wined3d_texture, i * levels + j, &wined3d_mip_desc);
                mip_desc->dwWidth = wined3d_mip_desc.width;
                mip_desc->dwHeight = wined3d_mip_desc.height;
 
                mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_MIPMAPSUBLEVEL;
            }
            else
            {
                mip_desc->ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
            }
 
            if (mip_desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
            {
                mip_desc->ddsCaps.dwCaps2 &= ~DDSCAPS2_CUBEMAP_ALLFACES;
 
                switch (i)
                {
                    case WINED3D_CUBEMAP_FACE_POSITIVE_X:
                        mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEX;
                        break;
                    case WINED3D_CUBEMAP_FACE_NEGATIVE_X:
                        mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEX;
                        break;
                    case WINED3D_CUBEMAP_FACE_POSITIVE_Y:
                        mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEY;
                        break;
                    case WINED3D_CUBEMAP_FACE_NEGATIVE_Y:
                        mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEY;
                        break;
                    case WINED3D_CUBEMAP_FACE_POSITIVE_Z:
                        mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_POSITIVEZ;
                        break;
                    case WINED3D_CUBEMAP_FACE_NEGATIVE_Z:
                        mip_desc->ddsCaps.dwCaps2 |= DDSCAPS2_CUBEMAP_NEGATIVEZ;
                        break;
                }
 
            }
 
            if (mip == root)
                continue;
 
            *attach = mip;
            attach = &mip->complex_array[0];
        }
    }
 
    if ((desc->dwFlags & DDSD_LPSURFACE) && FAILED(hr = wined3d_texture_update_desc(wined3d_texture,
            wined3d_desc.width, wined3d_desc.height, wined3d_desc.format,
            WINED3D_MULTISAMPLE_NONE, 0, desc->lpSurface, pitch)))
    {
        ERR("Failed to set surface memory, hr %#x.\n", hr);
        goto fail;
    }
 
    if (desc->dwFlags & DDSD_BACKBUFFERCOUNT)
    {
        unsigned int count = desc->u5.dwBackBufferCount;
        struct ddraw_surface *last = root;
 
        attach = &last->complex_array[0];
        for (i = 0; i < count; ++i)
        {
            if (!(texture = heap_alloc(sizeof(*texture))))
            {
                hr = E_OUTOFMEMORY;
                goto fail;
            }
 
            texture->version = version;
            texture->surface_desc = root->surface_desc;
            desc = &texture->surface_desc;
 
            /* Only one surface in the flipping chain is a back buffer, one is
             * a front buffer, the others are just flippable surfaces. */
            desc->ddsCaps.dwCaps &= ~(DDSCAPS_VISIBLE | DDSCAPS_PRIMARYSURFACE | DDSCAPS_FRONTBUFFER
                    | DDSCAPS_BACKBUFFER);
            if (!i)
                desc->ddsCaps.dwCaps |= DDSCAPS_BACKBUFFER;
            desc->u5.dwBackBufferCount = 0;
 
            if (FAILED(hr = wined3d_texture_create(ddraw->wined3d_device, &wined3d_desc, 1, 1,
                    WINED3D_TEXTURE_CREATE_GET_DC_LENIENT, NULL, texture,
                    &ddraw_texture_wined3d_parent_ops, &wined3d_texture)))
            {
                heap_free(texture);
                hr = hr_ddraw_from_wined3d(hr);
                goto fail;
            }
 
            last = wined3d_texture_get_sub_resource_parent(wined3d_texture, 0);
            wined3d_texture_decref(wined3d_texture);
            texture->root = last;
            wined3d_device_incref(texture->wined3d_device = ddraw->wined3d_device);
 
            if (desc->dwFlags & DDSD_CKDESTOVERLAY)
                wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTOVERLAY,
                        (struct wined3d_color_key *)&desc->u3.ddckCKDestOverlay);
            if (desc->dwFlags & DDSD_CKDESTBLT)
                wined3d_texture_set_color_key(wined3d_texture, DDCKEY_DESTBLT,
                        (struct wined3d_color_key *)&desc->ddckCKDestBlt);
            if (desc->dwFlags & DDSD_CKSRCOVERLAY)
                wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCOVERLAY,
                        (struct wined3d_color_key *)&desc->ddckCKSrcOverlay);
            if (desc->dwFlags & DDSD_CKSRCBLT)
                wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCBLT,
                        (struct wined3d_color_key *)&desc->ddckCKSrcBlt);
 
            *attach = last;
            attach = &last->complex_array[0];
        }
        *attach = root;
    }
 
    if (surface_desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
        ddraw->primary = root;
    *surface = root;
 
    return DD_OK;
 
fail:
    if (version == 7)
        IDirectDrawSurface7_Release(&root->IDirectDrawSurface7_iface);
    else if (version == 4)
        IDirectDrawSurface4_Release(&root->IDirectDrawSurface4_iface);
    else
        IDirectDrawSurface_Release(&root->IDirectDrawSurface_iface);
 
    return hr;
}

Referenced by ddraw1_CreateSurface(), ddraw2_CreateSurface(), ddraw4_CreateSurface(), and ddraw7_CreateSurface().

ddraw_surface_get_rendertarget_view()

struct wined3d_rendertarget_view * ddraw_surface_get_rendertarget_view

(

struct ddraw_surface *

surface

)

Definition at line 6520 of file surface.c.

{
    HRESULT hr;
 
    if (surface->wined3d_rtv)
        return surface->wined3d_rtv;
 
    if (FAILED(hr = wined3d_rendertarget_view_create_from_sub_resource(surface->wined3d_texture,
            surface->sub_resource_idx, surface, &ddraw_view_wined3d_parent_ops, &surface->wined3d_rtv)))
    {
        ERR("Failed to create rendertarget view, hr %#x.\n", hr);
        return NULL;
    }
 
    return surface->wined3d_rtv;
}

Referenced by d3d_device_init(), d3d_device_set_render_target(), d3d_device_update_depth_stencil(), ddraw_surface7_Flip(), and ddraw_surface_blt().

ddraw_surface_init()

void ddraw_surface_init	(	struct ddraw_surface *	surface,
		struct ddraw *	ddraw,
		struct wined3d_texture *	wined3d_texture,
		unsigned int	sub_resource_idx,
		const struct wined3d_parent_ops **	parent_ops
	)

Definition at line 6432 of file surface.c.

{
    struct ddraw_texture *texture = wined3d_texture_get_parent(wined3d_texture);
    unsigned int texture_level, row_pitch, slice_pitch;
    DDSURFACEDESC2 *desc = &surface->surface_desc;
    unsigned int version = texture->version;
 
    surface->IDirectDrawSurface7_iface.lpVtbl = &ddraw_surface7_vtbl;
    surface->IDirectDrawSurface4_iface.lpVtbl = &ddraw_surface4_vtbl;
    surface->IDirectDrawSurface3_iface.lpVtbl = &ddraw_surface3_vtbl;
    surface->IDirectDrawSurface2_iface.lpVtbl = &ddraw_surface2_vtbl;
    surface->IDirectDrawSurface_iface.lpVtbl = &ddraw_surface1_vtbl;
    surface->IDirectDrawGammaControl_iface.lpVtbl = &ddraw_gamma_control_vtbl;
    surface->IDirect3DTexture2_iface.lpVtbl = &d3d_texture2_vtbl;
    surface->IDirect3DTexture_iface.lpVtbl = &d3d_texture1_vtbl;
    surface->iface_count = 1;
    surface->version = version;
    surface->ddraw = ddraw;
 
    if (version == 7)
    {
        surface->ref7 = 1;
        surface->texture_outer = (IUnknown *)&surface->IDirectDrawSurface7_iface;
    }
    else if (version == 4)
    {
        surface->ref4 = 1;
        surface->texture_outer = (IUnknown *)&surface->IDirectDrawSurface4_iface;
    }
    else
    {
        surface->ref1 = 1;
        surface->texture_outer = (IUnknown *)&surface->IDirectDrawSurface_iface;
    }
 
    *desc = texture->surface_desc;
    surface->first_attached = surface;
 
    texture_level = desc->ddsCaps.dwCaps & DDSCAPS_MIPMAP ? sub_resource_idx % desc->u2.dwMipMapCount : 0;
    wined3d_texture_get_pitch(wined3d_texture, texture_level, &row_pitch, &slice_pitch);
    if (format_is_compressed(&desc->u4.ddpfPixelFormat))
    {
        if (desc->dwFlags & DDSD_LPSURFACE)
            desc->u1.dwLinearSize = ~0u;
        else
            desc->u1.dwLinearSize = slice_pitch;
        desc->dwFlags |= DDSD_LINEARSIZE;
        desc->dwFlags &= ~(DDSD_LPSURFACE | DDSD_PITCH);
    }
    else
    {
        if (!(desc->dwFlags & DDSD_LPSURFACE))
            desc->u1.lPitch = row_pitch;
        desc->dwFlags |= DDSD_PITCH;
        desc->dwFlags &= ~(DDSD_LPSURFACE | DDSD_LINEARSIZE);
    }
    desc->lpSurface = NULL;
 
    wined3d_texture_incref(surface->wined3d_texture = wined3d_texture);
    surface->sub_resource_idx = sub_resource_idx;
    *parent_ops = &ddraw_surface_wined3d_parent_ops;
 
    wined3d_private_store_init(&surface->private_store);
}

Referenced by device_parent_surface_created().

ddraw_surface_update_frontbuffer()

HRESULT ddraw_surface_update_frontbuffer	(	struct ddraw_surface *	surface,
		const RECT *	rect,
		BOOL	read
	)

Definition at line 43 of file surface.c.

{
    struct ddraw *ddraw = surface->ddraw;
    HDC surface_dc, screen_dc;
    int x, y, w, h;
    HRESULT hr;
    BOOL ret;
    RECT r;
 
    if (!rect)
    {
        SetRect(&r, 0, 0, surface->surface_desc.dwWidth, surface->surface_desc.dwHeight);
        rect = &r;
    }
 
    x = rect->left;
    y = rect->top;
    w = rect->right - rect->left;
    h = rect->bottom - rect->top;
 
    if (w <= 0 || h <= 0)
        return DD_OK;
 
    if (ddraw->swapchain_window && !(ddraw->flags & DDRAW_GDI_FLIP))
    {
        /* Nothing to do, we control the frontbuffer, or at least the parts we
         * care about. */
        if (read)
            return DD_OK;
 
        return wined3d_texture_blt(ddraw->wined3d_frontbuffer, 0, rect,
                surface->wined3d_texture, surface->sub_resource_idx, rect, 0, NULL, WINED3D_TEXF_POINT);
    }
 
    if (FAILED(hr = wined3d_texture_get_dc(surface->wined3d_texture, surface->sub_resource_idx, &surface_dc)))
    {
        ERR("Failed to get surface DC, hr %#x.\n", hr);
        return hr;
    }
    if (surface->palette)
        wined3d_palette_apply_to_dc(surface->palette->wined3d_palette, surface_dc);
 
    if (!(screen_dc = GetDC(NULL)))
    {
        wined3d_texture_release_dc(surface->wined3d_texture, surface->sub_resource_idx, surface_dc);
        ERR("Failed to get screen DC.\n");
        return E_FAIL;
    }
 
    if (read)
        ret = BitBlt(surface_dc, x, y, w, h,
                screen_dc, x, y, SRCCOPY);
    else
        ret = BitBlt(screen_dc, x, y, w, h,
                surface_dc, x, y, SRCCOPY);
 
    ReleaseDC(NULL, screen_dc);
    wined3d_texture_release_dc(surface->wined3d_texture, surface->sub_resource_idx, surface_dc);
 
    if (!ret)
    {
        ERR("Failed to blit to/from screen.\n");
        return E_FAIL;
    }
 
    return DD_OK;
}

Referenced by ddraw_palette_SetEntries(), ddraw_surface7_BltFast(), ddraw_surface7_Flip(), ddraw_surface7_GetDC(), ddraw_surface7_ReleaseDC(), ddraw_surface7_Unlock(), ddraw_surface_blt_clipped(), ddraw_surface_set_palette(), and surface_lock().

ddraw_update_lost_surfaces()

void ddraw_update_lost_surfaces

(

struct ddraw *

ddraw

)

Definition at line 4914 of file ddraw.c.

{
    struct ddraw_surface *surface;
 
    if (ddraw->device_state != DDRAW_DEVICE_STATE_NOT_RESTORED)
        return;
 
    LIST_FOR_EACH_ENTRY(surface, &ddraw->surface_list, struct ddraw_surface, surface_list_entry)
    {
        surface->is_lost = TRUE;
    }
    ddraw->device_state = DDRAW_DEVICE_STATE_OK;
}

Referenced by ddraw_surface7_Restore(), and device_parent_surface_created().

ddrawformat_from_wined3dformat()

void ddrawformat_from_wined3dformat	(	DDPIXELFORMAT *	ddraw_format,
		enum wined3d_format_id	wined3d_format
	)

Definition at line 33 of file utils.c.

{
    DWORD Size = DDPixelFormat->dwSize;
 
    if(Size==0) return;
 
    memset(DDPixelFormat, 0x00, Size);
    DDPixelFormat->dwSize = Size;
    switch (wined3d_format)
    {
        case WINED3DFMT_B8G8R8_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 24;
            DDPixelFormat->u2.dwRBitMask = 0x00ff0000;
            DDPixelFormat->u3.dwGBitMask = 0x0000ff00;
            DDPixelFormat->u4.dwBBitMask = 0x000000ff;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_B8G8R8A8_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 32;
            DDPixelFormat->u2.dwRBitMask = 0x00ff0000;
            DDPixelFormat->u3.dwGBitMask = 0x0000ff00;
            DDPixelFormat->u4.dwBBitMask = 0x000000ff;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0xff000000;
            break;
 
        case WINED3DFMT_B8G8R8X8_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 32;
            DDPixelFormat->u2.dwRBitMask = 0x00ff0000;
            DDPixelFormat->u3.dwGBitMask = 0x0000ff00;
            DDPixelFormat->u4.dwBBitMask = 0x000000ff;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_R8G8B8X8_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 32;
            DDPixelFormat->u2.dwRBitMask = 0x000000ff;
            DDPixelFormat->u3.dwGBitMask = 0x0000ff00;
            DDPixelFormat->u4.dwBBitMask = 0x00ff0000;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_B5G6R5_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 16;
            DDPixelFormat->u2.dwRBitMask = 0xF800;
            DDPixelFormat->u3.dwGBitMask = 0x07E0;
            DDPixelFormat->u4.dwBBitMask = 0x001F;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_B5G5R5X1_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 16;
            DDPixelFormat->u2.dwRBitMask = 0x7C00;
            DDPixelFormat->u3.dwGBitMask = 0x03E0;
            DDPixelFormat->u4.dwBBitMask = 0x001F;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_B5G5R5A1_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 16;
            DDPixelFormat->u2.dwRBitMask = 0x7C00;
            DDPixelFormat->u3.dwGBitMask = 0x03E0;
            DDPixelFormat->u4.dwBBitMask = 0x001F;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0x8000;
            break;
 
        case WINED3DFMT_B4G4R4A4_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 16;
            DDPixelFormat->u2.dwRBitMask = 0x0F00;
            DDPixelFormat->u3.dwGBitMask = 0x00F0;
            DDPixelFormat->u4.dwBBitMask = 0x000F;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0xF000;
            break;
 
        case WINED3DFMT_B2G3R3_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 8;
            DDPixelFormat->u2.dwRBitMask = 0xE0;
            DDPixelFormat->u3.dwGBitMask = 0x1C;
            DDPixelFormat->u4.dwBBitMask = 0x03;
            DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_P8_UINT:
            DDPixelFormat->dwFlags = DDPF_PALETTEINDEXED8 | DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 8;
            DDPixelFormat->u2.dwRBitMask = 0x00;
            DDPixelFormat->u3.dwGBitMask = 0x00;
            DDPixelFormat->u4.dwBBitMask = 0x00;
            break;
 
        case WINED3DFMT_A8_UNORM:
            DDPixelFormat->dwFlags = DDPF_ALPHA;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwAlphaBitDepth = 8;
            DDPixelFormat->u2.dwRBitMask = 0x0;
            DDPixelFormat->u3.dwZBitMask = 0x0;
            DDPixelFormat->u4.dwStencilBitMask = 0x0;
            DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_B2G3R3A8_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 16;
            DDPixelFormat->u2.dwRBitMask = 0x00E0;
            DDPixelFormat->u3.dwGBitMask = 0x001C;
            DDPixelFormat->u4.dwBBitMask = 0x0003;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0xFF00;
            break;
 
        case WINED3DFMT_B4G4R4X4_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwRGBBitCount = 16;
            DDPixelFormat->u2.dwRBitMask = 0x0F00;
            DDPixelFormat->u3.dwGBitMask = 0x00F0;
            DDPixelFormat->u4.dwBBitMask = 0x000F;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
            break;
 
        /* How are Z buffer bit depth and Stencil buffer bit depth related?
         */
        case WINED3DFMT_D16_UNORM:
            DDPixelFormat->dwFlags = DDPF_ZBUFFER;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwZBufferBitDepth = 16;
            DDPixelFormat->u2.dwStencilBitDepth = 0;
            DDPixelFormat->u3.dwZBitMask = 0x0000FFFF;
            DDPixelFormat->u4.dwStencilBitMask = 0x0;
            DDPixelFormat->u5.dwRGBZBitMask = 0x00000000;
            break;
 
        case WINED3DFMT_D32_UNORM:
            DDPixelFormat->dwFlags = DDPF_ZBUFFER;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwZBufferBitDepth = 32;
            DDPixelFormat->u2.dwStencilBitDepth = 0;
            DDPixelFormat->u3.dwZBitMask = 0xFFFFFFFF;
            DDPixelFormat->u4.dwStencilBitMask = 0x0;
            DDPixelFormat->u5.dwRGBZBitMask = 0x00000000;
            break;
 
        case WINED3DFMT_S4X4_UINT_D24_UNORM:
            DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER;
            DDPixelFormat->dwFourCC = 0;
            /* Should I set dwZBufferBitDepth to 32 here? */
            DDPixelFormat->u1.dwZBufferBitDepth = 32;
            DDPixelFormat->u2.dwStencilBitDepth = 4;
            DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF;
            DDPixelFormat->u4.dwStencilBitMask = 0x0F000000;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_D24_UNORM_S8_UINT:
            DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwZBufferBitDepth = 32;
            DDPixelFormat->u2.dwStencilBitDepth = 8;
            DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF;
            DDPixelFormat->u4.dwStencilBitMask = 0xFF000000;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_X8D24_UNORM:
            DDPixelFormat->dwFlags = DDPF_ZBUFFER;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwZBufferBitDepth = 32;
            DDPixelFormat->u2.dwStencilBitDepth = 0;
            DDPixelFormat->u3.dwZBitMask = 0x00FFFFFF;
            DDPixelFormat->u4.dwStencilBitMask = 0x00000000;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_S1_UINT_D15_UNORM:
            DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwZBufferBitDepth = 16;
            DDPixelFormat->u2.dwStencilBitDepth = 1;
            DDPixelFormat->u3.dwZBitMask = 0x7fff;
            DDPixelFormat->u4.dwStencilBitMask = 0x8000;
            DDPixelFormat->u5.dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_UYVY:
        case WINED3DFMT_YUY2:
            DDPixelFormat->u1.dwYUVBitCount = 16;
            DDPixelFormat->dwFlags = DDPF_FOURCC;
            DDPixelFormat->dwFourCC = wined3d_format;
            break;
 
        case WINED3DFMT_YV12:
            DDPixelFormat->u1.dwYUVBitCount = 12;
            DDPixelFormat->dwFlags = DDPF_FOURCC;
            DDPixelFormat->dwFourCC = wined3d_format;
            break;
 
        case WINED3DFMT_DXT1:
        case WINED3DFMT_DXT2:
        case WINED3DFMT_DXT3:
        case WINED3DFMT_DXT4:
        case WINED3DFMT_DXT5:
        case WINED3DFMT_MULTI2_ARGB8:
        case WINED3DFMT_G8R8_G8B8:
        case WINED3DFMT_R8G8_B8G8:
            DDPixelFormat->dwFlags = DDPF_FOURCC;
            DDPixelFormat->dwFourCC = wined3d_format;
            break;
 
        /* Luminance */
        case WINED3DFMT_L8_UNORM:
            DDPixelFormat->dwFlags = DDPF_LUMINANCE;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwLuminanceBitCount = 8;
            DDPixelFormat->u2.dwLuminanceBitMask = 0xff;
            DDPixelFormat->u3.dwBumpDvBitMask = 0x0;
            DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0;
            DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_L4A4_UNORM:
            DDPixelFormat->dwFlags = DDPF_ALPHAPIXELS | DDPF_LUMINANCE;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwLuminanceBitCount = 4;
            DDPixelFormat->u2.dwLuminanceBitMask = 0x0f;
            DDPixelFormat->u3.dwBumpDvBitMask = 0x0;
            DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0;
            DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0xf0;
            break;
 
        case WINED3DFMT_L8A8_UNORM:
            DDPixelFormat->dwFlags = DDPF_ALPHAPIXELS | DDPF_LUMINANCE;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwLuminanceBitCount = 16;
            DDPixelFormat->u2.dwLuminanceBitMask = 0x00ff;
            DDPixelFormat->u3.dwBumpDvBitMask = 0x0;
            DDPixelFormat->u4.dwBumpLuminanceBitMask = 0x0;
            DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0xff00;
            break;
 
        /* Bump mapping */
        case WINED3DFMT_R8G8_SNORM:
            DDPixelFormat->dwFlags = DDPF_BUMPDUDV;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwBumpBitCount = 16;
            DDPixelFormat->u2.dwBumpDuBitMask =         0x000000ff;
            DDPixelFormat->u3.dwBumpDvBitMask =         0x0000ff00;
            DDPixelFormat->u4.dwBumpLuminanceBitMask =  0x00000000;
            DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000;
            break;
 
        case WINED3DFMT_R5G5_SNORM_L6_UNORM:
            DDPixelFormat->dwFlags = DDPF_BUMPDUDV | DDPF_BUMPLUMINANCE;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwBumpBitCount = 16;
            DDPixelFormat->u2.dwBumpDuBitMask =         0x0000001f;
            DDPixelFormat->u3.dwBumpDvBitMask =         0x000003e0;
            DDPixelFormat->u4.dwBumpLuminanceBitMask =  0x0000fc00;
            DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000;
            break;
 
        case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
            DDPixelFormat->dwFlags = DDPF_BUMPDUDV | DDPF_BUMPLUMINANCE;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->u1.dwBumpBitCount = 32;
            DDPixelFormat->u2.dwBumpDuBitMask =         0x000000ff;
            DDPixelFormat->u3.dwBumpDvBitMask =         0x0000ff00;
            DDPixelFormat->u4.dwBumpLuminanceBitMask =  0x00ff0000;
            DDPixelFormat->u5.dwLuminanceAlphaBitMask = 0x00000000;
            break;
 
        default:
            FIXME("Unhandled wined3d format %#x.\n", wined3d_format);
            break;
    }
 
    if(TRACE_ON(ddraw)) {
        TRACE("Returning: ");
        DDRAW_dump_pixelformat(DDPixelFormat);
    }
}

Referenced by d3d7_EnumZBufferFormats(), d3d_device2_EnumTextureFormats(), d3d_device3_GetRenderState(), d3d_device3_SetRenderState(), d3d_device3_SetTexture(), d3d_device7_EnumTextureFormats(), ddraw7_EnumDisplayModes(), ddraw7_GetDisplayMode(), ddraw7_SetDisplayMode(), and ddraw_surface_create().

DDSD2_to_DDSD()

void DDSD2_to_DDSD	(	const DDSURFACEDESC2 *	in,
		DDSURFACEDESC *	out
	)

Definition at line 1262 of file utils.c.

{
    memset(out, 0, sizeof(*out));
    out->dwSize = sizeof(*out);
    out->dwFlags = in->dwFlags;
    if (in->dwFlags & DDSD_WIDTH) out->dwWidth = in->dwWidth;
    if (in->dwFlags & DDSD_HEIGHT) out->dwHeight = in->dwHeight;
    if (in->dwFlags & DDSD_PIXELFORMAT)
    {
        out->ddpfPixelFormat = in->u4.ddpfPixelFormat;
        if ((in->dwFlags & DDSD_CAPS) && (in->ddsCaps.dwCaps & DDSCAPS_ZBUFFER))
        {
            /* Z buffers have DDSD_ZBUFFERBITDEPTH set, but not DDSD_PIXELFORMAT. They do
             * have valid data in ddpfPixelFormat though */
            out->dwFlags &= ~DDSD_PIXELFORMAT;
            out->dwFlags |= DDSD_ZBUFFERBITDEPTH;
            out->u2.dwZBufferBitDepth = in->u4.ddpfPixelFormat.u1.dwZBufferBitDepth;
        }
    }
    /* ddsCaps is read even without DDSD_CAPS set. See dsurface:no_ddsd_caps_test */
    out->ddsCaps.dwCaps = in->ddsCaps.dwCaps;
    if (in->dwFlags & DDSD_PITCH) out->u1.lPitch = in->u1.lPitch;
    if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->dwBackBufferCount = in->u5.dwBackBufferCount;
    if (in->dwFlags & DDSD_ZBUFFERBITDEPTH) out->u2.dwZBufferBitDepth = in->u2.dwMipMapCount; /* same union */
    if (in->dwFlags & DDSD_ALPHABITDEPTH) out->dwAlphaBitDepth = in->dwAlphaBitDepth;
    /* DDraw(native, and wine) does not set the DDSD_LPSURFACE, so always copy */
    out->lpSurface = in->lpSurface;
    if (in->dwFlags & DDSD_CKDESTOVERLAY) out->ddckCKDestOverlay = in->u3.ddckCKDestOverlay;
    if (in->dwFlags & DDSD_CKDESTBLT) out->ddckCKDestBlt = in->ddckCKDestBlt;
    if (in->dwFlags & DDSD_CKSRCOVERLAY) out->ddckCKSrcOverlay = in->ddckCKSrcOverlay;
    if (in->dwFlags & DDSD_CKSRCBLT) out->ddckCKSrcBlt = in->ddckCKSrcBlt;
    if (in->dwFlags & DDSD_MIPMAPCOUNT) out->u2.dwMipMapCount = in->u2.dwMipMapCount;
    if (in->dwFlags & DDSD_REFRESHRATE) out->u2.dwRefreshRate = in->u2.dwRefreshRate;
    if (in->dwFlags & DDSD_LINEARSIZE) out->u1.dwLinearSize = in->u1.dwLinearSize;
    /* Does not exist in DDSURFACEDESC:
     * DDSD_TEXTURESTAGE, DDSD_FVF, DDSD_SRCVBHANDLE,
     */
    if (in->dwFlags & DDSD_TEXTURESTAGE) WARN("Does not exist in DDSURFACEDESC: DDSD_TEXTURESTAGE\n");
    if (in->dwFlags & DDSD_FVF) WARN("Does not exist in DDSURFACEDESC: DDSD_FVF\n");
    if (in->dwFlags & DDSD_SRCVBHANDLE) WARN("Does not exist in DDSURFACEDESC: DDSD_SRCVBHANDLE\n");
    out->dwFlags &= ~(DDSD_TEXTURESTAGE | DDSD_FVF | DDSD_SRCVBHANDLE);
}

Referenced by ddraw_surface1_Lock(), ddraw_surface2_Lock(), ddraw_surface3_GetSurfaceDesc(), ddraw_surface3_Lock(), and EnumDisplayModesCallbackThunk().

DDSD_to_DDSD2()

void DDSD_to_DDSD2	(	const DDSURFACEDESC *	in,
		DDSURFACEDESC2 *	out
	)

Definition at line 1218 of file utils.c.

{
    /* The output of this function is never passed to the application directly, so
     * the memset is not strictly needed. CreateSurface still has problems with this
     * though. Don't forget to set ddsCaps.dwCaps2/3/4 to 0 when removing this */
    memset(out, 0x00, sizeof(*out));
    out->dwSize = sizeof(*out);
    out->dwFlags = in->dwFlags & ~DDSD_ZBUFFERBITDEPTH;
    if (in->dwFlags & DDSD_WIDTH) out->dwWidth = in->dwWidth;
    if (in->dwFlags & DDSD_HEIGHT) out->dwHeight = in->dwHeight;
    if (in->dwFlags & DDSD_PIXELFORMAT) out->u4.ddpfPixelFormat = in->ddpfPixelFormat;
    else if(in->dwFlags & DDSD_ZBUFFERBITDEPTH)
    {
        out->dwFlags |= DDSD_PIXELFORMAT;
        memset(&out->u4.ddpfPixelFormat, 0, sizeof(out->u4.ddpfPixelFormat));
        out->u4.ddpfPixelFormat.dwSize = sizeof(out->u4.ddpfPixelFormat);
        out->u4.ddpfPixelFormat.dwFlags = DDPF_ZBUFFER;
        out->u4.ddpfPixelFormat.u1.dwZBufferBitDepth = in->u2.dwZBufferBitDepth;
        /* 0 is not a valid DDSURFACEDESC / DDPIXELFORMAT on either side of the
         * conversion */
        out->u4.ddpfPixelFormat.u3.dwZBitMask = ~0U >> (32 - in->u2.dwZBufferBitDepth);
    }
    /* ddsCaps is read even without DDSD_CAPS set. See dsurface:no_ddsd_caps_test */
    out->ddsCaps.dwCaps = in->ddsCaps.dwCaps;
    if (in->dwFlags & DDSD_PITCH) out->u1.lPitch = in->u1.lPitch;
    if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->u5.dwBackBufferCount = in->dwBackBufferCount;
    if (in->dwFlags & DDSD_ALPHABITDEPTH) out->dwAlphaBitDepth = in->dwAlphaBitDepth;
    /* DDraw(native, and wine) does not set the DDSD_LPSURFACE, so always copy */
    out->lpSurface = in->lpSurface;
    if (in->dwFlags & DDSD_CKDESTOVERLAY) out->u3.ddckCKDestOverlay = in->ddckCKDestOverlay;
    if (in->dwFlags & DDSD_CKDESTBLT) out->ddckCKDestBlt = in->ddckCKDestBlt;
    if (in->dwFlags & DDSD_CKSRCOVERLAY) out->ddckCKSrcOverlay = in->ddckCKSrcOverlay;
    if (in->dwFlags & DDSD_CKSRCBLT) out->ddckCKSrcBlt = in->ddckCKSrcBlt;
    if (in->dwFlags & DDSD_MIPMAPCOUNT) out->u2.dwMipMapCount = in->u2.dwMipMapCount;
    if (in->dwFlags & DDSD_REFRESHRATE) out->u2.dwRefreshRate = in->u2.dwRefreshRate;
    if (in->dwFlags & DDSD_LINEARSIZE) out->u1.dwLinearSize = in->u1.dwLinearSize;
    /* Does not exist in DDSURFACEDESC:
     * DDSD_TEXTURESTAGE, DDSD_FVF, DDSD_SRCVBHANDLE,
     */
}

Referenced by ddraw1_CreateSurface(), ddraw1_EnumDisplayModes(), ddraw1_EnumSurfaces(), ddraw2_CreateSurface(), ddraw2_EnumDisplayModes(), ddraw2_EnumSurfaces(), ddraw_surface1_Initialize(), ddraw_surface2_Initialize(), ddraw_surface3_Initialize(), and ddraw_surface3_SetSurfaceDesc().

dump_D3DMATRIX()

void dump_D3DMATRIX

(

const D3DMATRIX *

mat

)

Definition at line 914 of file utils.c.

{
    TRACE("  %f %f %f %f\n", mat->_11, mat->_12, mat->_13, mat->_14);
    TRACE("  %f %f %f %f\n", mat->_21, mat->_22, mat->_23, mat->_24);
    TRACE("  %f %f %f %f\n", mat->_31, mat->_32, mat->_33, mat->_34);
    TRACE("  %f %f %f %f\n", mat->_41, mat->_42, mat->_43, mat->_44);
}

Referenced by d3d_device1_SetMatrix().

format_is_compressed()

static BOOL format_is_compressed ( const DDPIXELFORMAT *  format )

inlinestatic

Definition at line 602 of file ddraw_private.h.

{
    return (format->dwFlags & DDPF_FOURCC) && (format->dwFourCC == WINED3DFMT_DXT1
            || format->dwFourCC == WINED3DFMT_DXT2 || format->dwFourCC == WINED3DFMT_DXT3
            || format->dwFourCC == WINED3DFMT_DXT4 || format->dwFourCC == WINED3DFMT_DXT5);
}

Referenced by ddraw_surface_create(), and ddraw_surface_init().

format_is_paletteindexed()

static BOOL format_is_paletteindexed ( const DDPIXELFORMAT *  fmt )

inlinestatic

Definition at line 609 of file ddraw_private.h.

{
    DWORD flags = DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2 | DDPF_PALETTEINDEXED4
            | DDPF_PALETTEINDEXED8 | DDPF_PALETTEINDEXEDTO8;
    return !!(fmt->dwFlags & flags);
}

Referenced by ddraw_surface7_GetDC(), ddraw_surface_set_palette(), and validate_surface_palette().

get_flexible_vertex_size()

DWORD get_flexible_vertex_size

(

DWORD

d3dvtVertexType

)

Definition at line 923 of file utils.c.

{
    DWORD size = 0;
    DWORD i;
 
    if (d3dvtVertexType & D3DFVF_NORMAL) size += 3 * sizeof(D3DVALUE);
    if (d3dvtVertexType & D3DFVF_DIFFUSE) size += sizeof(DWORD);
    if (d3dvtVertexType & D3DFVF_SPECULAR) size += sizeof(DWORD);
    if (d3dvtVertexType & D3DFVF_RESERVED1) size += sizeof(DWORD);
    switch (d3dvtVertexType & D3DFVF_POSITION_MASK)
    {
        case D3DFVF_XYZ:    size += 3 * sizeof(D3DVALUE); break;
        case D3DFVF_XYZRHW: size += 4 * sizeof(D3DVALUE); break;
        case D3DFVF_XYZB1:  size += 4 * sizeof(D3DVALUE); break;
        case D3DFVF_XYZB2:  size += 5 * sizeof(D3DVALUE); break;
        case D3DFVF_XYZB3:  size += 6 * sizeof(D3DVALUE); break;
        case D3DFVF_XYZB4:  size += 7 * sizeof(D3DVALUE); break;
        case D3DFVF_XYZB5:  size += 8 * sizeof(D3DVALUE); break;
        default: ERR("Unexpected position mask\n");
    }
    for (i = 0; i < GET_TEXCOUNT_FROM_FVF(d3dvtVertexType); i++)
    {
        size += GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, i) * sizeof(D3DVALUE);
    }
 
    return size;
}

Referenced by d3d_device3_Begin(), d3d_device7_DrawIndexedPrimitive(), d3d_device7_DrawIndexedPrimitiveStrided(), d3d_device7_DrawIndexedPrimitiveVB(), d3d_device7_DrawPrimitive(), d3d_device7_DrawPrimitiveStrided(), d3d_device7_DrawPrimitiveVB(), d3d_vertex_buffer7_GetVertexBufferDesc(), d3d_vertex_buffer7_ProcessVertices(), d3d_vertex_buffer_create(), and process_vertices_strided().

hr_ddraw_from_wined3d()

HRESULT hr_ddraw_from_wined3d

(

HRESULT

hr

)

Definition at line 1206 of file utils.c.

{
    switch(hr)
    {
        case WINED3DERR_INVALIDCALL: return DDERR_INVALIDPARAMS;
        default: return hr;
    }
}

Referenced by d3d_device7_BeginStateBlock(), d3d_device7_CreateStateBlock(), d3d_device7_EndStateBlock(), d3d_device7_GetLight(), d3d_device7_GetLightEnable(), d3d_device7_LightEnable(), d3d_device7_SetLight(), ddraw_surface7_SetPrivateData(), ddraw_surface7_SetSurfaceDesc(), ddraw_surface_create(), and ddraw_surface_set_color_key().

impl_from_IDirect3DDevice()

static struct d3d_device * impl_from_IDirect3DDevice ( IDirect3DDevice *  iface )

inlinestatic

Definition at line 358 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice_iface);
}

Referenced by d3d_device1_AddRef(), d3d_device1_AddViewport(), d3d_device1_BeginScene(), d3d_device1_CreateExecuteBuffer(), d3d_device1_CreateMatrix(), d3d_device1_DeleteMatrix(), d3d_device1_DeleteViewport(), d3d_device1_EndScene(), d3d_device1_EnumTextureFormats(), d3d_device1_Execute(), d3d_device1_GetCaps(), d3d_device1_GetDirect3D(), d3d_device1_GetMatrix(), d3d_device1_GetStats(), d3d_device1_NextViewport(), d3d_device1_QueryInterface(), d3d_device1_Release(), d3d_device1_SetMatrix(), and d3d_device1_SwapTextureHandles().

impl_from_IDirect3DDevice2()

static struct d3d_device * impl_from_IDirect3DDevice2 ( IDirect3DDevice2 *  iface )

inlinestatic

Definition at line 363 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice2_iface);
}

Referenced by d3d_device2_AddRef(), d3d_device2_AddViewport(), d3d_device2_Begin(), d3d_device2_BeginIndexed(), d3d_device2_BeginScene(), d3d_device2_DeleteViewport(), d3d_device2_DrawIndexedPrimitive(), d3d_device2_DrawPrimitive(), d3d_device2_End(), d3d_device2_EndScene(), d3d_device2_EnumTextureFormats(), d3d_device2_GetCaps(), d3d_device2_GetClipStatus(), d3d_device2_GetCurrentViewport(), d3d_device2_GetDirect3D(), d3d_device2_GetLightState(), d3d_device2_GetRenderState(), d3d_device2_GetRenderTarget(), d3d_device2_GetStats(), d3d_device2_GetTransform(), d3d_device2_Index(), d3d_device2_MultiplyTransform(), d3d_device2_NextViewport(), d3d_device2_QueryInterface(), d3d_device2_Release(), d3d_device2_SetClipStatus(), d3d_device2_SetCurrentViewport(), d3d_device2_SetLightState(), d3d_device2_SetRenderState(), d3d_device2_SetRenderTarget(), d3d_device2_SetTransform(), d3d_device2_SwapTextureHandles(), and d3d_device2_Vertex().

impl_from_IDirect3DDevice3()

static struct d3d_device * impl_from_IDirect3DDevice3 ( IDirect3DDevice3 *  iface )

inlinestatic

Definition at line 368 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice3_iface);
}

Referenced by d3d_device3_AddRef(), d3d_device3_AddViewport(), d3d_device3_Begin(), d3d_device3_BeginScene(), d3d_device3_ComputeSphereVisibility(), d3d_device3_DeleteViewport(), d3d_device3_DrawIndexedPrimitive(), d3d_device3_DrawIndexedPrimitiveStrided(), d3d_device3_DrawIndexedPrimitiveVB(), d3d_device3_DrawPrimitive(), d3d_device3_DrawPrimitiveStrided(), d3d_device3_DrawPrimitiveVB(), d3d_device3_End(), d3d_device3_EndScene(), d3d_device3_EnumTextureFormats(), d3d_device3_GetCaps(), d3d_device3_GetClipStatus(), d3d_device3_GetCurrentViewport(), d3d_device3_GetDirect3D(), d3d_device3_GetLightState(), d3d_device3_GetRenderState(), d3d_device3_GetRenderTarget(), d3d_device3_GetTexture(), d3d_device3_GetTextureStageState(), d3d_device3_GetTransform(), d3d_device3_MultiplyTransform(), d3d_device3_NextViewport(), d3d_device3_QueryInterface(), d3d_device3_Release(), d3d_device3_SetClipStatus(), d3d_device3_SetCurrentViewport(), d3d_device3_SetLightState(), d3d_device3_SetRenderState(), d3d_device3_SetRenderTarget(), d3d_device3_SetTexture(), d3d_device3_SetTextureStageState(), d3d_device3_SetTransform(), d3d_device3_ValidateDevice(), and d3d_device3_Vertex().

impl_from_IDirect3DDevice7()

static struct d3d_device * impl_from_IDirect3DDevice7 ( IDirect3DDevice7 *  iface )

inlinestatic

Definition at line 373 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice7_iface);
}

Referenced by d3d_device7_AddRef(), d3d_device7_ApplyStateBlock(), d3d_device7_BeginScene(), d3d_device7_BeginStateBlock(), d3d_device7_CaptureStateBlock(), d3d_device7_Clear(), d3d_device7_ComputeSphereVisibility(), d3d_device7_CreateStateBlock(), d3d_device7_DeleteStateBlock(), d3d_device7_DrawIndexedPrimitive(), d3d_device7_DrawIndexedPrimitiveStrided(), d3d_device7_DrawIndexedPrimitiveVB(), d3d_device7_DrawPrimitive(), d3d_device7_DrawPrimitiveStrided(), d3d_device7_DrawPrimitiveVB(), d3d_device7_EndScene(), d3d_device7_EndStateBlock(), d3d_device7_EnumTextureFormats(), d3d_device7_GetCaps(), d3d_device7_GetClipPlane(), d3d_device7_GetDirect3D(), d3d_device7_GetLight(), d3d_device7_GetLightEnable(), d3d_device7_GetMaterial(), d3d_device7_GetRenderState(), d3d_device7_GetRenderTarget(), d3d_device7_GetTexture(), d3d_device7_GetTextureStageState(), d3d_device7_GetTransform(), d3d_device7_GetViewport(), d3d_device7_LightEnable(), d3d_device7_Load(), d3d_device7_MultiplyTransform(), d3d_device7_QueryInterface(), d3d_device7_Release(), d3d_device7_SetClipPlane(), d3d_device7_SetLight(), d3d_device7_SetMaterial(), d3d_device7_SetRenderState(), d3d_device7_SetRenderTarget(), d3d_device7_SetTexture(), d3d_device7_SetTextureStageState(), d3d_device7_SetTransform(), d3d_device7_SetViewport(), and d3d_device7_ValidateDevice().

impl_from_IDirect3DTexture()

static struct ddraw_surface * impl_from_IDirect3DTexture ( IDirect3DTexture *  iface )

inlinestatic

Definition at line 223 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirect3DTexture_iface);
}

Referenced by d3d_texture1_AddRef(), d3d_texture1_GetHandle(), d3d_texture1_Load(), d3d_texture1_PaletteChanged(), d3d_texture1_QueryInterface(), and d3d_texture1_Release().

impl_from_IDirect3DTexture2()

static struct ddraw_surface * impl_from_IDirect3DTexture2 ( IDirect3DTexture2 *  iface )

inlinestatic

Definition at line 228 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirect3DTexture2_iface);
}

Referenced by d3d_texture2_AddRef(), d3d_texture2_GetHandle(), d3d_texture2_Load(), d3d_texture2_QueryInterface(), and d3d_texture2_Release().

impl_from_IDirectDrawPalette()

static struct ddraw_palette * impl_from_IDirectDrawPalette ( IDirectDrawPalette *  iface )

inlinestatic

Definition at line 410 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct ddraw_palette, IDirectDrawPalette_iface);
}

Referenced by ddraw1_CreatePalette(), ddraw2_CreatePalette(), ddraw4_CreatePalette(), ddraw_palette_AddRef(), ddraw_palette_GetCaps(), ddraw_palette_GetEntries(), ddraw_palette_Release(), and ddraw_palette_SetEntries().

impl_from_IDirectDrawSurface()

static struct ddraw_surface * impl_from_IDirectDrawSurface ( IDirectDrawSurface *  iface )

inlinestatic

Definition at line 233 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface_iface);
}

Referenced by ddraw_surface1_AddAttachedSurface(), ddraw_surface1_AddOverlayDirtyRect(), ddraw_surface1_AddRef(), ddraw_surface1_Blt(), ddraw_surface1_BltBatch(), ddraw_surface1_BltFast(), ddraw_surface1_DeleteAttachedSurface(), ddraw_surface1_EnumAttachedSurfaces(), ddraw_surface1_EnumOverlayZOrders(), ddraw_surface1_Flip(), ddraw_surface1_GetAttachedSurface(), ddraw_surface1_GetBltStatus(), ddraw_surface1_GetCaps(), ddraw_surface1_GetClipper(), ddraw_surface1_GetColorKey(), ddraw_surface1_GetDC(), ddraw_surface1_GetFlipStatus(), ddraw_surface1_GetOverlayPosition(), ddraw_surface1_GetPalette(), ddraw_surface1_GetPixelFormat(), ddraw_surface1_GetSurfaceDesc(), ddraw_surface1_Initialize(), ddraw_surface1_IsLost(), ddraw_surface1_Lock(), ddraw_surface1_QueryInterface(), ddraw_surface1_Release(), ddraw_surface1_ReleaseDC(), ddraw_surface1_Restore(), ddraw_surface1_SetClipper(), ddraw_surface1_SetColorKey(), ddraw_surface1_SetOverlayPosition(), ddraw_surface1_SetPalette(), ddraw_surface1_Unlock(), ddraw_surface1_UpdateOverlay(), ddraw_surface1_UpdateOverlayDisplay(), and ddraw_surface1_UpdateOverlayZOrder().

impl_from_IDirectDrawSurface2()

static struct ddraw_surface * impl_from_IDirectDrawSurface2 ( IDirectDrawSurface2 *  iface )

inlinestatic

Definition at line 238 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface2_iface);
}

Referenced by ddraw_surface2_AddAttachedSurface(), ddraw_surface2_AddOverlayDirtyRect(), ddraw_surface2_AddRef(), ddraw_surface2_Blt(), ddraw_surface2_BltBatch(), ddraw_surface2_BltFast(), ddraw_surface2_DeleteAttachedSurface(), ddraw_surface2_EnumAttachedSurfaces(), ddraw_surface2_EnumOverlayZOrders(), ddraw_surface2_Flip(), ddraw_surface2_GetAttachedSurface(), ddraw_surface2_GetBltStatus(), ddraw_surface2_GetCaps(), ddraw_surface2_GetClipper(), ddraw_surface2_GetColorKey(), ddraw_surface2_GetDC(), ddraw_surface2_GetDDInterface(), ddraw_surface2_GetFlipStatus(), ddraw_surface2_GetOverlayPosition(), ddraw_surface2_GetPalette(), ddraw_surface2_GetPixelFormat(), ddraw_surface2_GetSurfaceDesc(), ddraw_surface2_Initialize(), ddraw_surface2_IsLost(), ddraw_surface2_Lock(), ddraw_surface2_PageLock(), ddraw_surface2_PageUnlock(), ddraw_surface2_QueryInterface(), ddraw_surface2_Release(), ddraw_surface2_ReleaseDC(), ddraw_surface2_Restore(), ddraw_surface2_SetClipper(), ddraw_surface2_SetColorKey(), ddraw_surface2_SetOverlayPosition(), ddraw_surface2_SetPalette(), ddraw_surface2_Unlock(), ddraw_surface2_UpdateOverlay(), ddraw_surface2_UpdateOverlayDisplay(), and ddraw_surface2_UpdateOverlayZOrder().

impl_from_IDirectDrawSurface3()

static struct ddraw_surface * impl_from_IDirectDrawSurface3 ( IDirectDrawSurface3 *  iface )

inlinestatic

Definition at line 243 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface3_iface);
}

Referenced by ddraw_surface3_AddAttachedSurface(), ddraw_surface3_AddOverlayDirtyRect(), ddraw_surface3_AddRef(), ddraw_surface3_Blt(), ddraw_surface3_BltBatch(), ddraw_surface3_BltFast(), ddraw_surface3_DeleteAttachedSurface(), ddraw_surface3_EnumAttachedSurfaces(), ddraw_surface3_EnumOverlayZOrders(), ddraw_surface3_Flip(), ddraw_surface3_GetAttachedSurface(), ddraw_surface3_GetBltStatus(), ddraw_surface3_GetCaps(), ddraw_surface3_GetClipper(), ddraw_surface3_GetColorKey(), ddraw_surface3_GetDC(), ddraw_surface3_GetDDInterface(), ddraw_surface3_GetFlipStatus(), ddraw_surface3_GetOverlayPosition(), ddraw_surface3_GetPalette(), ddraw_surface3_GetPixelFormat(), ddraw_surface3_GetSurfaceDesc(), ddraw_surface3_Initialize(), ddraw_surface3_IsLost(), ddraw_surface3_Lock(), ddraw_surface3_PageLock(), ddraw_surface3_PageUnlock(), ddraw_surface3_QueryInterface(), ddraw_surface3_Release(), ddraw_surface3_ReleaseDC(), ddraw_surface3_Restore(), ddraw_surface3_SetClipper(), ddraw_surface3_SetColorKey(), ddraw_surface3_SetOverlayPosition(), ddraw_surface3_SetPalette(), ddraw_surface3_SetSurfaceDesc(), ddraw_surface3_Unlock(), ddraw_surface3_UpdateOverlay(), ddraw_surface3_UpdateOverlayDisplay(), and ddraw_surface3_UpdateOverlayZOrder().

impl_from_IDirectDrawSurface4()

static struct ddraw_surface * impl_from_IDirectDrawSurface4 ( IDirectDrawSurface4 *  iface )

inlinestatic

Definition at line 248 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface4_iface);
}

Referenced by ddraw_surface4_AddAttachedSurface(), ddraw_surface4_AddOverlayDirtyRect(), ddraw_surface4_AddRef(), ddraw_surface4_Blt(), ddraw_surface4_BltBatch(), ddraw_surface4_BltFast(), ddraw_surface4_ChangeUniquenessValue(), ddraw_surface4_DeleteAttachedSurface(), ddraw_surface4_EnumAttachedSurfaces(), ddraw_surface4_EnumOverlayZOrders(), ddraw_surface4_Flip(), ddraw_surface4_FreePrivateData(), ddraw_surface4_GetAttachedSurface(), ddraw_surface4_GetBltStatus(), ddraw_surface4_GetCaps(), ddraw_surface4_GetClipper(), ddraw_surface4_GetColorKey(), ddraw_surface4_GetDC(), ddraw_surface4_GetDDInterface(), ddraw_surface4_GetFlipStatus(), ddraw_surface4_GetOverlayPosition(), ddraw_surface4_GetPalette(), ddraw_surface4_GetPixelFormat(), ddraw_surface4_GetPrivateData(), ddraw_surface4_GetSurfaceDesc(), ddraw_surface4_GetUniquenessValue(), ddraw_surface4_Initialize(), ddraw_surface4_IsLost(), ddraw_surface4_Lock(), ddraw_surface4_PageLock(), ddraw_surface4_PageUnlock(), ddraw_surface4_QueryInterface(), ddraw_surface4_Release(), ddraw_surface4_ReleaseDC(), ddraw_surface4_Restore(), ddraw_surface4_SetClipper(), ddraw_surface4_SetColorKey(), ddraw_surface4_SetOverlayPosition(), ddraw_surface4_SetPalette(), ddraw_surface4_SetPrivateData(), ddraw_surface4_SetSurfaceDesc(), ddraw_surface4_Unlock(), ddraw_surface4_UpdateOverlay(), ddraw_surface4_UpdateOverlayDisplay(), and ddraw_surface4_UpdateOverlayZOrder().

impl_from_IDirectDrawSurface7()

static struct ddraw_surface * impl_from_IDirectDrawSurface7 ( IDirectDrawSurface7 *  iface )

inlinestatic

Definition at line 253 of file ddraw_private.h.

{
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface7_iface);
}

Referenced by d3d_device2_GetRenderTarget(), d3d_device3_GetRenderTarget(), d3d_device_update_depth_stencil(), ddraw1_DuplicateSurface(), ddraw1_GetGDISurface(), ddraw2_DuplicateSurface(), ddraw2_GetGDISurface(), ddraw4_DuplicateSurface(), ddraw4_GetGDISurface(), ddraw4_GetSurfaceFromDC(), ddraw7_FlipToGDISurface(), ddraw_surface1_GetAttachedSurface(), ddraw_surface2_GetAttachedSurface(), ddraw_surface3_GetAttachedSurface(), ddraw_surface4_GetAttachedSurface(), ddraw_surface7_AddAttachedSurface(), ddraw_surface7_AddRef(), ddraw_surface7_Blt(), ddraw_surface7_BltFast(), ddraw_surface7_DeleteAttachedSurface(), ddraw_surface7_EnumAttachedSurfaces(), ddraw_surface7_Flip(), ddraw_surface7_FreePrivateData(), ddraw_surface7_GetAttachedSurface(), ddraw_surface7_GetCaps(), ddraw_surface7_GetClipper(), ddraw_surface7_GetColorKey(), ddraw_surface7_GetDC(), ddraw_surface7_GetDDInterface(), ddraw_surface7_GetLOD(), ddraw_surface7_GetOverlayPosition(), ddraw_surface7_GetPalette(), ddraw_surface7_GetPixelFormat(), ddraw_surface7_GetPriority(), ddraw_surface7_GetPrivateData(), ddraw_surface7_GetSurfaceDesc(), ddraw_surface7_IsLost(), ddraw_surface7_Lock(), ddraw_surface7_QueryInterface(), ddraw_surface7_Release(), ddraw_surface7_ReleaseDC(), ddraw_surface7_Restore(), ddraw_surface7_SetClipper(), ddraw_surface7_SetColorKey(), ddraw_surface7_SetLOD(), ddraw_surface7_SetOverlayPosition(), ddraw_surface7_SetPalette(), ddraw_surface7_SetPriority(), ddraw_surface7_SetPrivateData(), ddraw_surface7_SetSurfaceDesc(), ddraw_surface7_Unlock(), ddraw_surface7_UpdateOverlay(), ddraw_surface7_UpdateOverlayZOrder(), EnumCallback(), EnumCallback2(), EnumSurfacesCallback2Thunk(), EnumSurfacesCallbackThunk(), and get_sub_mimaplevel().

light_activate()

void light_activate

(

struct d3d_light *

light

)

Definition at line 51 of file light.c.

{
    struct d3d_device *device;
 
    TRACE("light %p.\n", light);
 
    if (!light->active_viewport || !light->active_viewport->active_device) return;
    device = light->active_viewport->active_device;
 
    light_update(light);
    if (!(light->light.dwFlags & D3DLIGHT_ACTIVE))
    {
        IDirect3DDevice7_LightEnable(&device->IDirect3DDevice7_iface, light->dwLightIndex, TRUE);
        light->light.dwFlags |= D3DLIGHT_ACTIVE;
    }
}

Referenced by d3d_light_SetLight(), d3d_viewport_AddLight(), and viewport_activate().

light_deactivate()

void light_deactivate

(

struct d3d_light *

light

)

Definition at line 75 of file light.c.

{
    struct d3d_device *device;
 
    TRACE("light %p.\n", light);
 
    if (!light->active_viewport || !light->active_viewport->active_device) return;
    device = light->active_viewport->active_device;
 
    if (light->light.dwFlags & D3DLIGHT_ACTIVE)
    {
        IDirect3DDevice7_LightEnable(&device->IDirect3DDevice7_iface, light->dwLightIndex, FALSE);
        light->light.dwFlags &= ~D3DLIGHT_ACTIVE;
    }
}

Referenced by d3d_light_SetLight(), and d3d_viewport_DeleteLight().

material_activate()

void material_activate

(

struct d3d_material *

material

)

Definition at line 447 of file material.c.

{
    D3DMATERIAL7 d3d7mat;
 
    TRACE("Activating material %p.\n", material);
 
    d3d7mat.u.diffuse = material->mat.u.diffuse;
    d3d7mat.u1.ambient = material->mat.u1.ambient;
    d3d7mat.u2.specular = material->mat.u2.specular;
    d3d7mat.u3.emissive = material->mat.u3.emissive;
    d3d7mat.u4.power = material->mat.u4.power;
 
    IDirect3DDevice7_SetMaterial(&material->active_device->IDirect3DDevice7_iface, &d3d7mat);
}

Referenced by d3d_device3_SetLightState().

multiply_matrix()

void multiply_matrix	(	D3DMATRIX *	dst,
		const D3DMATRIX *	src1,
		const D3DMATRIX *	src2
	)

Definition at line 1173 of file utils.c.

{
    D3DMATRIX temp;
 
    /* Now do the multiplication 'by hand'.
       I know that all this could be optimised, but this will be done later :-) */
    temp._11 = (src1->_11 * src2->_11) + (src1->_21 * src2->_12) + (src1->_31 * src2->_13) + (src1->_41 * src2->_14);
    temp._21 = (src1->_11 * src2->_21) + (src1->_21 * src2->_22) + (src1->_31 * src2->_23) + (src1->_41 * src2->_24);
    temp._31 = (src1->_11 * src2->_31) + (src1->_21 * src2->_32) + (src1->_31 * src2->_33) + (src1->_41 * src2->_34);
    temp._41 = (src1->_11 * src2->_41) + (src1->_21 * src2->_42) + (src1->_31 * src2->_43) + (src1->_41 * src2->_44);
 
    temp._12 = (src1->_12 * src2->_11) + (src1->_22 * src2->_12) + (src1->_32 * src2->_13) + (src1->_42 * src2->_14);
    temp._22 = (src1->_12 * src2->_21) + (src1->_22 * src2->_22) + (src1->_32 * src2->_23) + (src1->_42 * src2->_24);
    temp._32 = (src1->_12 * src2->_31) + (src1->_22 * src2->_32) + (src1->_32 * src2->_33) + (src1->_42 * src2->_34);
    temp._42 = (src1->_12 * src2->_41) + (src1->_22 * src2->_42) + (src1->_32 * src2->_43) + (src1->_42 * src2->_44);
 
    temp._13 = (src1->_13 * src2->_11) + (src1->_23 * src2->_12) + (src1->_33 * src2->_13) + (src1->_43 * src2->_14);
    temp._23 = (src1->_13 * src2->_21) + (src1->_23 * src2->_22) + (src1->_33 * src2->_23) + (src1->_43 * src2->_24);
    temp._33 = (src1->_13 * src2->_31) + (src1->_23 * src2->_32) + (src1->_33 * src2->_33) + (src1->_43 * src2->_34);
    temp._43 = (src1->_13 * src2->_41) + (src1->_23 * src2->_42) + (src1->_33 * src2->_43) + (src1->_43 * src2->_44);
 
    temp._14 = (src1->_14 * src2->_11) + (src1->_24 * src2->_12) + (src1->_34 * src2->_13) + (src1->_44 * src2->_14);
    temp._24 = (src1->_14 * src2->_21) + (src1->_24 * src2->_22) + (src1->_34 * src2->_23) + (src1->_44 * src2->_24);
    temp._34 = (src1->_14 * src2->_31) + (src1->_24 * src2->_32) + (src1->_34 * src2->_33) + (src1->_44 * src2->_34);
    temp._44 = (src1->_14 * src2->_41) + (src1->_24 * src2->_42) + (src1->_34 * src2->_43) + (src1->_44 * src2->_44);
 
    /* And copy the new matrix in the good storage.. */
    memcpy(dest, &temp, 16 * sizeof(D3DVALUE));
}

Referenced by d3d_device3_MultiplyTransform(), d3d_device3_SetTransform(), d3d_viewport_TransformVertices(), get_modelview_matrix(), get_projection_matrix(), get_texture_matrix(), prepare_clip_space_planes(), process_vertices_strided(), update_clip_space(), and wined3d_device_multiply_transform().

unsafe_impl_from_IDirect3DDevice()

struct d3d_device * unsafe_impl_from_IDirect3DDevice

(

IDirect3DDevice *

iface

)

Definition at line 6871 of file device.c.

{
    if (!iface) return NULL;
    assert(iface->lpVtbl == &d3d_device1_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice_iface);
}

Referenced by d3d_material1_GetHandle(), and d3d_texture1_GetHandle().

unsafe_impl_from_IDirect3DDevice2()

struct d3d_device * unsafe_impl_from_IDirect3DDevice2

(

IDirect3DDevice2 *

iface

)

Definition at line 6864 of file device.c.

{
    if (!iface) return NULL;
    assert(iface->lpVtbl == &d3d_device2_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice2_iface);
}

Referenced by d3d_material2_GetHandle(), and d3d_texture2_GetHandle().

unsafe_impl_from_IDirect3DDevice3()

struct d3d_device * unsafe_impl_from_IDirect3DDevice3

(

IDirect3DDevice3 *

iface

)

Definition at line 6857 of file device.c.

{
    if (!iface) return NULL;
    assert(iface->lpVtbl == &d3d_device3_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice3_iface);
}

Referenced by d3d_material3_GetHandle(), and d3d_vertex_buffer7_ProcessVertices().

unsafe_impl_from_IDirect3DDevice7()

struct d3d_device * unsafe_impl_from_IDirect3DDevice7

(

IDirect3DDevice7 *

iface

)

Definition at line 6850 of file device.c.

{
    if (!iface) return NULL;
    assert((iface->lpVtbl == &d3d_device7_fpu_preserve_vtbl) || (iface->lpVtbl == &d3d_device7_fpu_setup_vtbl));
    return CONTAINING_RECORD(iface, struct d3d_device, IDirect3DDevice7_iface);
}

Referenced by d3d_vertex_buffer7_ProcessVertices().

unsafe_impl_from_IDirect3DExecuteBuffer()

struct d3d_execute_buffer * unsafe_impl_from_IDirect3DExecuteBuffer

(

IDirect3DExecuteBuffer *

iface

)

Definition at line 809 of file executebuffer.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d_execute_buffer_vtbl);
 
    return impl_from_IDirect3DExecuteBuffer(iface);
}

Referenced by d3d_device1_Execute().

unsafe_impl_from_IDirect3DLight()

struct d3d_light * unsafe_impl_from_IDirect3DLight

(

IDirect3DLight *

iface

)

Definition at line 254 of file light.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d_light_vtbl);
 
    return impl_from_IDirect3DLight(iface);
}

Referenced by d3d_viewport_AddLight(), d3d_viewport_DeleteLight(), and d3d_viewport_NextLight().

unsafe_impl_from_IDirect3DTexture()

struct ddraw_surface * unsafe_impl_from_IDirect3DTexture

(

IDirect3DTexture *

iface

)

Definition at line 5728 of file surface.c.

{
    if (!iface) return NULL;
    assert(iface->lpVtbl == &d3d_texture1_vtbl);
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirect3DTexture_iface);
}

Referenced by d3d_device1_SwapTextureHandles(), and d3d_texture1_Load().

unsafe_impl_from_IDirect3DTexture2()

struct ddraw_surface * unsafe_impl_from_IDirect3DTexture2

(

IDirect3DTexture2 *

iface

)

Definition at line 5721 of file surface.c.

{
    if (!iface) return NULL;
    assert(iface->lpVtbl == &d3d_texture2_vtbl);
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirect3DTexture2_iface);
}

Referenced by d3d_device2_SwapTextureHandles(), d3d_device3_SetTexture(), and d3d_texture2_Load().

unsafe_impl_from_IDirect3DVertexBuffer()

struct d3d_vertex_buffer * unsafe_impl_from_IDirect3DVertexBuffer

(

IDirect3DVertexBuffer *

iface

)

unsafe_impl_from_IDirect3DVertexBuffer7()

struct d3d_vertex_buffer * unsafe_impl_from_IDirect3DVertexBuffer7

(

IDirect3DVertexBuffer7 *

iface

)

Definition at line 486 of file vertexbuffer.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &d3d_vertex_buffer7_vtbl);
 
    return impl_from_IDirect3DVertexBuffer7(iface);
}

Referenced by d3d_device3_DrawIndexedPrimitiveVB(), d3d_device3_DrawPrimitiveVB(), d3d_device7_DrawIndexedPrimitiveVB(), d3d_device7_DrawPrimitiveVB(), and d3d_vertex_buffer7_ProcessVertices().

unsafe_impl_from_IDirect3DViewport()

struct d3d_viewport * unsafe_impl_from_IDirect3DViewport

(

IDirect3DViewport *

iface

)

Definition at line 1138 of file viewport.c.

{
    /* IDirect3DViewport and IDirect3DViewport3 use the same iface. */
    if (!iface) return NULL;
    assert(iface->lpVtbl == (IDirect3DViewportVtbl *)&d3d_viewport_vtbl);
    return CONTAINING_RECORD((IDirect3DViewport3 *)iface, struct d3d_viewport, IDirect3DViewport3_iface);
}

Referenced by d3d_device1_AddViewport(), d3d_device1_DeleteViewport(), d3d_device1_Execute(), and d3d_device1_NextViewport().

unsafe_impl_from_IDirect3DViewport2()

struct d3d_viewport * unsafe_impl_from_IDirect3DViewport2

(

IDirect3DViewport2 *

iface

)

Definition at line 1130 of file viewport.c.

{
    /* IDirect3DViewport and IDirect3DViewport3 use the same iface. */
    if (!iface) return NULL;
    assert(iface->lpVtbl == (IDirect3DViewport2Vtbl *)&d3d_viewport_vtbl);
    return CONTAINING_RECORD((IDirect3DViewport3 *)iface, struct d3d_viewport, IDirect3DViewport3_iface);
}

Referenced by d3d_device2_AddViewport(), d3d_device2_DeleteViewport(), d3d_device2_NextViewport(), and d3d_device2_SetCurrentViewport().

unsafe_impl_from_IDirect3DViewport3()

struct d3d_viewport * unsafe_impl_from_IDirect3DViewport3

(

IDirect3DViewport3 *

iface

)

Definition at line 1123 of file viewport.c.

{
    if (!iface) return NULL;
    assert(iface->lpVtbl == &d3d_viewport_vtbl);
    return CONTAINING_RECORD(iface, struct d3d_viewport, IDirect3DViewport3_iface);
}

Referenced by d3d_device3_AddViewport(), d3d_device3_DeleteViewport(), d3d_device3_NextViewport(), and d3d_device3_SetCurrentViewport().

unsafe_impl_from_IDirectDrawClipper()

struct ddraw_clipper * unsafe_impl_from_IDirectDrawClipper

(

IDirectDrawClipper *

iface

)

Definition at line 329 of file clipper.c.

{
    if (!iface)
        return NULL;
    assert(iface->lpVtbl == &ddraw_clipper_vtbl);
 
    return impl_from_IDirectDrawClipper(iface);
}

Referenced by ddraw_surface7_SetClipper().

unsafe_impl_from_IDirectDrawPalette()

struct ddraw_palette * unsafe_impl_from_IDirectDrawPalette

(

IDirectDrawPalette *

iface

)

Definition at line 234 of file palette.c.

{
    if (!iface) return NULL;
    assert(iface->lpVtbl == &ddraw_palette_vtbl);
    return CONTAINING_RECORD(iface, struct ddraw_palette, IDirectDrawPalette_iface);
}

Referenced by ddraw_surface_set_palette().

unsafe_impl_from_IDirectDrawSurface()

struct ddraw_surface * unsafe_impl_from_IDirectDrawSurface

(

IDirectDrawSurface *

iface

)

Definition at line 5705 of file surface.c.

{
    if (!iface) return NULL;
    if (iface->lpVtbl != &ddraw_surface1_vtbl)
    {
        HRESULT hr = IDirectDrawSurface_QueryInterface(iface, &IID_IDirectDrawSurface, (void **)&iface);
        if (FAILED(hr))
        {
            WARN("Object %p doesn't expose interface IDirectDrawSurface.\n", iface);
            return NULL;
        }
        IDirectDrawSurface_Release(iface);
    }
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface_iface);
}

Referenced by d3d2_CreateDevice(), d3d_device2_SetRenderTarget(), ddraw1_DuplicateSurface(), ddraw2_DuplicateSurface(), ddraw_surface1_AddAttachedSurface(), ddraw_surface1_Blt(), ddraw_surface1_BltFast(), ddraw_surface1_DeleteAttachedSurface(), ddraw_surface1_Flip(), ddraw_surface1_UpdateOverlay(), and ddraw_surface1_UpdateOverlayZOrder().

unsafe_impl_from_IDirectDrawSurface4()

struct ddraw_surface * unsafe_impl_from_IDirectDrawSurface4

(

IDirectDrawSurface4 *

iface

)

Definition at line 5657 of file surface.c.

{
    if (!iface) return NULL;
    if (iface->lpVtbl != &ddraw_surface4_vtbl)
    {
        HRESULT hr = IDirectDrawSurface4_QueryInterface(iface, &IID_IDirectDrawSurface4, (void **)&iface);
        if (FAILED(hr))
        {
            WARN("Object %p doesn't expose interface IDirectDrawSurface4.\n", iface);
            return NULL;
        }
        IDirectDrawSurface4_Release(iface);
    }
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface4_iface);
}

Referenced by d3d3_CreateDevice(), d3d_device3_SetRenderTarget(), ddraw4_DuplicateSurface(), ddraw_surface4_AddAttachedSurface(), ddraw_surface4_Blt(), ddraw_surface4_BltFast(), ddraw_surface4_DeleteAttachedSurface(), ddraw_surface4_Flip(), ddraw_surface4_UpdateOverlay(), and ddraw_surface4_UpdateOverlayZOrder().

unsafe_impl_from_IDirectDrawSurface7()

struct ddraw_surface * unsafe_impl_from_IDirectDrawSurface7

(

IDirectDrawSurface7 *

iface

)

Definition at line 5641 of file surface.c.

{
    if (!iface) return NULL;
    if (iface->lpVtbl != &ddraw_surface7_vtbl)
    {
        HRESULT hr = IDirectDrawSurface7_QueryInterface(iface, &IID_IDirectDrawSurface7, (void **)&iface);
        if (FAILED(hr))
        {
            WARN("Object %p doesn't expose interface IDirectDrawSurface7.\n", iface);
            return NULL;
        }
        IDirectDrawSurface7_Release(iface);
    }
    return CONTAINING_RECORD(iface, struct ddraw_surface, IDirectDrawSurface7_iface);
}

Referenced by copy_mipmap_chain(), d3d7_CreateDevice(), d3d_device3_GetTexture(), d3d_device7_Load(), d3d_device7_PreLoad(), d3d_device7_SetRenderTarget(), d3d_device7_SetTexture(), ddraw7_DuplicateSurface(), ddraw7_EnumSurfaces(), ddraw_surface7_AddAttachedSurface(), ddraw_surface7_Blt(), ddraw_surface7_BltFast(), ddraw_surface7_DeleteAttachedSurface(), ddraw_surface7_Flip(), ddraw_surface7_UpdateOverlay(), and is_mip_level_subset().

viewport_activate()

void viewport_activate	(	struct d3d_viewport *	viewport,
		BOOL	ignore_lights
	)

Definition at line 55 of file viewport.c.

{
    struct wined3d_vec3 scale, offset;
    D3DVIEWPORT7 vp;
 
    if (!ignore_lights)
    {
        struct d3d_light *light;
 
        /* Activate all the lights associated with this context */
        LIST_FOR_EACH_ENTRY(light, &This->light_list, struct d3d_light, entry)
        {
            light_activate(light);
        }
    }
 
    /* And copy the values in the structure used by the device */
    if (This->use_vp2)
    {
        vp.dwX = This->viewports.vp2.dwX;
        vp.dwY = This->viewports.vp2.dwY;
        vp.dwHeight = This->viewports.vp2.dwHeight;
        vp.dwWidth = This->viewports.vp2.dwWidth;
        vp.dvMinZ = 0.0f;
        vp.dvMaxZ = 1.0f;
 
        scale.x = 2.0f / This->viewports.vp2.dvClipWidth;
        scale.y = 2.0f / This->viewports.vp2.dvClipHeight;
        scale.z = 1.0f / (This->viewports.vp2.dvMaxZ - This->viewports.vp2.dvMinZ);
        offset.x = -2.0f * This->viewports.vp2.dvClipX / This->viewports.vp2.dvClipWidth - 1.0f;
        offset.y = -2.0f * This->viewports.vp2.dvClipY / This->viewports.vp2.dvClipHeight + 1.0f;
        offset.z = -This->viewports.vp2.dvMinZ / (This->viewports.vp2.dvMaxZ - This->viewports.vp2.dvMinZ);
    }
    else
    {
        vp.dwX = This->viewports.vp1.dwX;
        vp.dwY = This->viewports.vp1.dwY;
        vp.dwHeight = This->viewports.vp1.dwHeight;
        vp.dwWidth = This->viewports.vp1.dwWidth;
        vp.dvMinZ = 0.0f;
        vp.dvMaxZ = 1.0f;
 
        scale.x = 2.0f * This->viewports.vp1.dvScaleX / This->viewports.vp1.dwWidth;
        scale.y = 2.0f * This->viewports.vp1.dvScaleY / This->viewports.vp1.dwHeight;
        scale.z = 1.0f;
        offset.x = 0.0f;
        offset.y = 0.0f;
        offset.z = 0.0f;
    }
 
    update_clip_space(This->active_device, &scale, &offset);
    IDirect3DDevice7_SetViewport(&This->active_device->IDirect3DDevice7_iface, &vp);
}

Referenced by d3d_device3_SetCurrentViewport(), d3d_viewport_Clear(), d3d_viewport_Clear2(), d3d_viewport_SetViewport(), d3d_viewport_SetViewport2(), and d3d_viewport_TransformVertices().

wined3d_colour_from_ddraw_colour()

BOOL wined3d_colour_from_ddraw_colour	(	const DDPIXELFORMAT *	pf,
		const struct ddraw_palette *	palette,
		DWORD	colour,
		struct wined3d_color *	wined3d_colour
	)

Definition at line 596 of file utils.c.

{
    if (pf->dwFlags & DDPF_ALPHA)
    {
        DWORD size, mask;
 
        size = pf->u1.dwAlphaBitDepth;
        mask = size < 32 ? (1u << size) - 1 : ~0u;
        wined3d_colour->r = 0.0f;
        wined3d_colour->g = 0.0f;
        wined3d_colour->b = 0.0f;
        wined3d_colour->a = colour_to_float(colour, mask);
        return TRUE;
    }
 
    if (pf->dwFlags & DDPF_FOURCC)
    {
        WARN("FourCC formats not supported.\n");
        goto fail;
    }
 
    if (pf->dwFlags & DDPF_PALETTEINDEXED8)
    {
        PALETTEENTRY entry;
 
        colour &= 0xff;
        if (!palette || FAILED(wined3d_palette_get_entries(palette->wined3d_palette, 0, colour, 1, &entry)))
        {
            wined3d_colour->r = 0.0f;
            wined3d_colour->g = 0.0f;
            wined3d_colour->b = 0.0f;
        }
        else
        {
            wined3d_colour->r = entry.peRed / 255.0f;
            wined3d_colour->g = entry.peGreen / 255.0f;
            wined3d_colour->b = entry.peBlue / 255.0f;
        }
        wined3d_colour->a = colour / 255.0f;
        return TRUE;
    }
 
    if (pf->dwFlags & DDPF_RGB)
    {
        wined3d_colour->r = colour_to_float(colour, pf->u2.dwRBitMask);
        wined3d_colour->g = colour_to_float(colour, pf->u3.dwGBitMask);
        wined3d_colour->b = colour_to_float(colour, pf->u4.dwBBitMask);
        if (pf->dwFlags & DDPF_ALPHAPIXELS)
            wined3d_colour->a = colour_to_float(colour, pf->u5.dwRGBAlphaBitMask);
        else
            wined3d_colour->a = 0.0f;
        return TRUE;
    }
 
    if (pf->dwFlags & DDPF_ZBUFFER)
    {
        wined3d_colour->r = colour_to_float(colour, pf->u3.dwZBitMask);
        if (pf->dwFlags & DDPF_STENCILBUFFER)
            wined3d_colour->g = colour_to_float(colour, pf->u4.dwStencilBitMask);
        else
            wined3d_colour->g = 0.0f;
        wined3d_colour->b = 0.0f;
        wined3d_colour->a = 0.0f;
        return TRUE;
    }
 
    FIXME("Unhandled pixel format.\n");
    DDRAW_dump_pixelformat(pf);
 
fail:
    wined3d_colour->r = 0.0f;
    wined3d_colour->g = 0.0f;
    wined3d_colour->b = 0.0f;
    wined3d_colour->a = 0.0f;
 
    return FALSE;
}

Referenced by ddraw_surface_blt().

wined3dformat_from_ddrawformat()

enum wined3d_format_id wined3dformat_from_ddrawformat

(

const DDPIXELFORMAT *

format

)

Definition at line 333 of file utils.c.

{
    TRACE("Convert a DirectDraw Pixelformat to a WineD3D Pixelformat\n");
    if(TRACE_ON(ddraw))
    {
        DDRAW_dump_pixelformat(DDPixelFormat);
    }
 
    if(DDPixelFormat->dwFlags & DDPF_PALETTEINDEXED8)
    {
        return WINED3DFMT_P8_UINT;
    }
    else if(DDPixelFormat->dwFlags & (DDPF_PALETTEINDEXED1 | DDPF_PALETTEINDEXED2 | DDPF_PALETTEINDEXED4) )
    {
        FIXME("DDPF_PALETTEINDEXED1 to DDPF_PALETTEINDEXED4 are not supported by WineD3D (yet). Returning WINED3DFMT_P8\n");
        return WINED3DFMT_P8_UINT;
    }
    else if(DDPixelFormat->dwFlags & DDPF_RGB)
    {
        switch(DDPixelFormat->u1.dwRGBBitCount)
        {
            case 8:
                /* This is the only format that can match here */
                return WINED3DFMT_B2G3R3_UNORM;
 
            case 16:
                /* Read the Color masks */
                if( (DDPixelFormat->u2.dwRBitMask == 0xF800) &&
                    (DDPixelFormat->u3.dwGBitMask == 0x07E0) &&
                    (DDPixelFormat->u4.dwBBitMask == 0x001F) )
                {
                    return WINED3DFMT_B5G6R5_UNORM;
                }
 
                if( (DDPixelFormat->u2.dwRBitMask == 0x7C00) &&
                    (DDPixelFormat->u3.dwGBitMask == 0x03E0) &&
                    (DDPixelFormat->u4.dwBBitMask == 0x001F) )
                {
                    if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
                        (DDPixelFormat->u5.dwRGBAlphaBitMask == 0x8000))
                        return WINED3DFMT_B5G5R5A1_UNORM;
                    else
                        return WINED3DFMT_B5G5R5X1_UNORM;
                }
 
                if( (DDPixelFormat->u2.dwRBitMask == 0x0F00) &&
                    (DDPixelFormat->u3.dwGBitMask == 0x00F0) &&
                    (DDPixelFormat->u4.dwBBitMask == 0x000F) )
                {
                    if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
                        (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xF000))
                        return WINED3DFMT_B4G4R4A4_UNORM;
                    else
                        return WINED3DFMT_B4G4R4X4_UNORM;
                }
 
                if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
                    (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xFF00) &&
                    (DDPixelFormat->u2.dwRBitMask == 0x00E0) &&
                    (DDPixelFormat->u3.dwGBitMask == 0x001C) &&
                    (DDPixelFormat->u4.dwBBitMask == 0x0003) )
                {
                    return WINED3DFMT_B2G3R3A8_UNORM;
                }
                WARN("16 bit RGB Pixel format does not match.\n");
                return WINED3DFMT_UNKNOWN;
 
            case 24:
                return WINED3DFMT_B8G8R8_UNORM;
 
            case 32:
                /* Read the Color masks */
                if( (DDPixelFormat->u2.dwRBitMask == 0x00FF0000) &&
                    (DDPixelFormat->u3.dwGBitMask == 0x0000FF00) &&
                    (DDPixelFormat->u4.dwBBitMask == 0x000000FF) )
                {
                    if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
                        (DDPixelFormat->u5.dwRGBAlphaBitMask == 0xFF000000))
                        return WINED3DFMT_B8G8R8A8_UNORM;
                    else
                        return WINED3DFMT_B8G8R8X8_UNORM;
 
                }
                WARN("32 bit RGB pixel format does not match.\n");
                return WINED3DFMT_UNKNOWN;
 
            default:
                WARN("Invalid dwRGBBitCount in Pixelformat structure.\n");
                return WINED3DFMT_UNKNOWN;
        }
    }
    else if( (DDPixelFormat->dwFlags & DDPF_ALPHA) )
    {
        /* Alpha only Pixelformat */
        switch(DDPixelFormat->u1.dwAlphaBitDepth)
        {
            case 8:
                return WINED3DFMT_A8_UNORM;
 
            default:
                WARN("Invalid AlphaBitDepth in Alpha-Only Pixelformat.\n");
                return WINED3DFMT_UNKNOWN;
        }
    }
    else if(DDPixelFormat->dwFlags & DDPF_LUMINANCE)
    {
        /* Luminance-only or luminance-alpha */
        if(DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS)
        {
            /* Luminance with Alpha */
            switch(DDPixelFormat->u1.dwLuminanceBitCount)
            {
                case 4:
                    if(DDPixelFormat->u1.dwAlphaBitDepth == 4)
                        return WINED3DFMT_L4A4_UNORM;
                    WARN("Unknown Alpha / Luminance bit depth combination.\n");
                    return WINED3DFMT_UNKNOWN;
 
                case 6:
                    FIXME("A luminance Pixelformat shouldn't have 6 luminance bits. Returning D3DFMT_L6V5U5 for now.\n");
                    return WINED3DFMT_R5G5_SNORM_L6_UNORM;
 
                case 8:
                    if(DDPixelFormat->u1.dwAlphaBitDepth == 8)
                        return WINED3DFMT_L8A8_UNORM;
                    WARN("Unknown Alpha / Lumincase bit depth combination.\n");
                    return WINED3DFMT_UNKNOWN;
            }
        }
        else
        {
            /* Luminance-only */
            switch(DDPixelFormat->u1.dwLuminanceBitCount)
            {
                case 6:
                    FIXME("A luminance Pixelformat shouldn't have 6 luminance bits. Returning D3DFMT_L6V5U5 for now.\n");
                    return WINED3DFMT_R5G5_SNORM_L6_UNORM;
 
                case 8:
                    return WINED3DFMT_L8_UNORM;
 
                default:
                    WARN("Unknown luminance-only bit depth 0x%x.\n", DDPixelFormat->u1.dwLuminanceBitCount);
                    return WINED3DFMT_UNKNOWN;
             }
        }
    }
    else if(DDPixelFormat->dwFlags & DDPF_ZBUFFER)
    {
        /* Z buffer */
        if(DDPixelFormat->dwFlags & DDPF_STENCILBUFFER)
        {
            switch(DDPixelFormat->u1.dwZBufferBitDepth)
            {
                case 16:
                    if (DDPixelFormat->u2.dwStencilBitDepth == 1) return WINED3DFMT_S1_UINT_D15_UNORM;
                    WARN("Unknown depth stencil format: 16 z bits, %u stencil bits.\n",
                            DDPixelFormat->u2.dwStencilBitDepth);
                    return WINED3DFMT_UNKNOWN;
 
                case 32:
                    if (DDPixelFormat->u2.dwStencilBitDepth == 8) return WINED3DFMT_D24_UNORM_S8_UINT;
                    else if (DDPixelFormat->u2.dwStencilBitDepth == 4) return WINED3DFMT_S4X4_UINT_D24_UNORM;
                    WARN("Unknown depth stencil format: 32 z bits, %u stencil bits.\n",
                            DDPixelFormat->u2.dwStencilBitDepth);
                    return WINED3DFMT_UNKNOWN;
 
                default:
                    WARN("Unknown depth stencil format: %u z bits, %u stencil bits.\n",
                            DDPixelFormat->u1.dwZBufferBitDepth, DDPixelFormat->u2.dwStencilBitDepth);
                    return WINED3DFMT_UNKNOWN;
            }
        }
        else
        {
            switch(DDPixelFormat->u1.dwZBufferBitDepth)
            {
                case 16:
                    return WINED3DFMT_D16_UNORM;
 
                case 24:
                    return WINED3DFMT_X8D24_UNORM;
 
                case 32:
                    if (DDPixelFormat->u3.dwZBitMask == 0x00FFFFFF) return WINED3DFMT_X8D24_UNORM;
                    else if (DDPixelFormat->u3.dwZBitMask == 0xFFFFFF00) return WINED3DFMT_X8D24_UNORM;
                    else if (DDPixelFormat->u3.dwZBitMask == 0xFFFFFFFF) return WINED3DFMT_D32_UNORM;
                    WARN("Unknown depth-only format: 32 z bits, mask 0x%08x\n",
                            DDPixelFormat->u3.dwZBitMask);
                    return WINED3DFMT_UNKNOWN;
 
                default:
                    WARN("Unknown depth-only format: %u z bits, mask 0x%08x\n",
                            DDPixelFormat->u1.dwZBufferBitDepth, DDPixelFormat->u3.dwZBitMask);
                    return WINED3DFMT_UNKNOWN;
            }
        }
    }
    else if(DDPixelFormat->dwFlags & DDPF_FOURCC)
    {
        return DDPixelFormat->dwFourCC;
    }
    else if(DDPixelFormat->dwFlags & DDPF_BUMPDUDV)
    {
        if( (DDPixelFormat->u1.dwBumpBitCount         == 16        ) &&
            (DDPixelFormat->u2.dwBumpDuBitMask        == 0x000000ff) &&
            (DDPixelFormat->u3.dwBumpDvBitMask        == 0x0000ff00) &&
            (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x00000000) )
        {
            return WINED3DFMT_R8G8_SNORM;
        }
        else if ( (DDPixelFormat->u1.dwBumpBitCount         == 16        ) &&
                  (DDPixelFormat->u2.dwBumpDuBitMask        == 0x0000001f) &&
                  (DDPixelFormat->u3.dwBumpDvBitMask        == 0x000003e0) &&
                  (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x0000fc00) )
        {
            return WINED3DFMT_R5G5_SNORM_L6_UNORM;
        }
        else if ( (DDPixelFormat->u1.dwBumpBitCount         == 32        ) &&
                  (DDPixelFormat->u2.dwBumpDuBitMask        == 0x000000ff) &&
                  (DDPixelFormat->u3.dwBumpDvBitMask        == 0x0000ff00) &&
                  (DDPixelFormat->u4.dwBumpLuminanceBitMask == 0x00ff0000) )
        {
            return WINED3DFMT_R8G8_SNORM_L8X8_UNORM;
        }
    }
 
    WARN("Unknown Pixelformat.\n");
    return WINED3DFMT_UNKNOWN;
}

Referenced by ddraw_surface7_SetSurfaceDesc(), and ddraw_surface_create().

wined3dmapflags_from_ddrawmapflags()

unsigned int wined3dmapflags_from_ddrawmapflags

(

unsigned int

flags

)

Definition at line 564 of file utils.c.

{
    static const unsigned int handled = DDLOCK_NOSYSLOCK
            | DDLOCK_NOOVERWRITE
            | DDLOCK_DISCARDCONTENTS
            | DDLOCK_DONOTWAIT;
    unsigned int wined3d_flags;
 
    wined3d_flags = flags & handled;
    if (!(flags & (DDLOCK_NOOVERWRITE | DDLOCK_DISCARDCONTENTS | DDLOCK_WRITEONLY)))
        wined3d_flags |= WINED3D_MAP_READ;
    if (!(flags & DDLOCK_READONLY))
        wined3d_flags |= WINED3D_MAP_WRITE;
    if (!(wined3d_flags & (WINED3D_MAP_READ | WINED3D_MAP_WRITE)))
        wined3d_flags |= WINED3D_MAP_READ | WINED3D_MAP_WRITE;
    if (flags & DDLOCK_NODIRTYUPDATE)
        wined3d_flags |= WINED3D_MAP_NO_DIRTY_UPDATE;
    flags &= ~(handled | DDLOCK_WAIT | DDLOCK_READONLY | DDLOCK_WRITEONLY | DDLOCK_NODIRTYUPDATE);
 
    if (flags)
        FIXME("Unhandled flags %#x.\n", flags);
 
    return wined3d_flags;
}

Referenced by d3d_vertex_buffer7_Lock(), and surface_lock().

Variable Documentation

DECLSPEC_HIDDEN

const GUID IID_D3DDEVICE_WineD3D DECLSPEC_HIDDEN

extern

Definition at line 43 of file ddraw_private.h.