ddraw_private.h File Reference

#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include "wine/debug.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	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_SWAPPED   0x00000040
#define	DDRAW_STRIDE_ALIGNMENT   8
#define	DDRAW_WINED3D_FLAGS
#define	DDRAW_WINED3D_SWAPCHAIN_FLAGS
#define	DDRAW_MAX_ACTIVE_LIGHTS   32
#define	DDRAW_MAX_TEXTURES   8
#define	DDRAW_WINDOW_CLASS_NAME   "DirectDrawDeviceWnd"
#define	DDRAW_SURFACE_LOCATION_DEFAULT   0x00000001
#define	DDRAW_SURFACE_LOCATION_DRAW   0x00000002
#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	DDRAW_SURFACE_READ   0x00000001
#define	DDRAW_SURFACE_WRITE   0x00000002
#define	DDRAW_SURFACE_RW   (DDRAW_SURFACE_READ | DDRAW_SURFACE_WRITE)
#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 }
enum	ddraw_viewport_version { DDRAW_VIEWPORT_VERSION_NONE , DDRAW_VIEWPORT_VERSION_1 , DDRAW_VIEWPORT_VERSION_2 }

Functions
HRESULT	ddraw_init (struct ddraw *ddraw, DWORD flags, enum wined3d_device_type device_type)
void	ddraw_d3dcaps1_from_7 (D3DDEVICEDESC *caps1, D3DDEVICEDESC7 *caps7)
HRESULT	ddraw_get_d3dcaps (const struct ddraw *ddraw, D3DDEVICEDESC7 *caps)
void	ddraw_update_lost_surfaces (struct ddraw *ddraw)
static void	ddraw_set_swapchain_window (struct ddraw *ddraw, HWND window)
void	DDRAW_Convert_DDSCAPS_1_To_2 (const DDSCAPS *pIn, DDSCAPS2 *pOut)
void	DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1 (const DDDEVICEIDENTIFIER2 *pIn, DDDEVICEIDENTIFIER *pOut)
struct wined3d_vertex_declaration *	ddraw_find_decl (struct ddraw *ddraw, DWORD fvf)
HRESULT	ddraw_surface_create (struct ddraw *ddraw, const DDSURFACEDESC2 *surface_desc, struct ddraw_surface **surface, IUnknown *outer_unknown, unsigned int version)
struct wined3d_rendertarget_view *	ddraw_surface_get_rendertarget_view (struct ddraw_surface *surface)
HRESULT	ddraw_surface_update_frontbuffer (struct ddraw_surface *surface, const RECT *rect, BOOL read, unsigned int swap_interval)
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)
struct ddraw_surface *	unsafe_impl_from_IDirectDrawSurface4 (IDirectDrawSurface4 *iface)
struct ddraw_surface *	unsafe_impl_from_IDirectDrawSurface7 (IDirectDrawSurface7 *iface)
struct ddraw_surface *	unsafe_impl_from_IDirect3DTexture (IDirect3DTexture *iface)
struct ddraw_surface *	unsafe_impl_from_IDirect3DTexture2 (IDirect3DTexture2 *iface)
BOOL	ddraw_handle_table_init (struct ddraw_handle_table *t, UINT initial_size)
void	ddraw_handle_table_destroy (struct ddraw_handle_table *t)
DWORD	ddraw_allocate_handle (struct ddraw_handle_table *t, void *object, enum ddraw_handle_type type)
void *	ddraw_free_handle (struct ddraw_handle_table *t, DWORD handle, enum ddraw_handle_type type)
void *	ddraw_get_object (struct ddraw_handle_table *t, DWORD handle, enum ddraw_handle_type type)
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)
enum wined3d_depth_buffer_type	d3d_device_update_depth_stencil (struct d3d_device *device)
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)
struct d3d_device *	unsafe_impl_from_IDirect3DDevice2 (IDirect3DDevice2 *iface)
struct d3d_device *	unsafe_impl_from_IDirect3DDevice3 (IDirect3DDevice3 *iface)
struct d3d_device *	unsafe_impl_from_IDirect3DDevice7 (IDirect3DDevice7 *iface)
HRESULT	ddraw_clipper_init (struct ddraw_clipper *clipper)
struct ddraw_clipper *	unsafe_impl_from_IDirectDrawClipper (IDirectDrawClipper *iface)
BOOL	ddraw_clipper_is_valid (const struct ddraw_clipper *clipper)
static struct ddraw_palette *	impl_from_IDirectDrawPalette (IDirectDrawPalette *iface)
struct ddraw_palette *	unsafe_impl_from_IDirectDrawPalette (IDirectDrawPalette *iface)
HRESULT	ddraw_palette_init (struct ddraw_palette *palette, struct ddraw *ddraw, DWORD flags, PALETTEENTRY *entries)
void	light_activate (struct d3d_light *light)
void	light_deactivate (struct d3d_light *light)
void	d3d_light_init (struct d3d_light *light, struct ddraw *ddraw)
struct d3d_light *	unsafe_impl_from_IDirect3DLight (IDirect3DLight *iface)
void	material_activate (struct d3d_material *material)
struct d3d_material *	d3d_material_create (struct ddraw *ddraw)
struct d3d_viewport *	unsafe_impl_from_IDirect3DViewport3 (IDirect3DViewport3 *iface)
struct d3d_viewport *	unsafe_impl_from_IDirect3DViewport2 (IDirect3DViewport2 *iface)
struct d3d_viewport *	unsafe_impl_from_IDirect3DViewport (IDirect3DViewport *iface)
void	viewport_activate (struct d3d_viewport *viewport, BOOL ignore_lights)
void	viewport_deactivate (struct d3d_viewport *viewport)
void	d3d_viewport_init (struct d3d_viewport *viewport, struct ddraw *ddraw)
HRESULT	d3d_execute_buffer_init (struct d3d_execute_buffer *execute_buffer, struct d3d_device *device, D3DEXECUTEBUFFERDESC *desc)
struct d3d_execute_buffer *	unsafe_impl_from_IDirect3DExecuteBuffer (IDirect3DExecuteBuffer *iface)
HRESULT	d3d_execute_buffer_execute (struct d3d_execute_buffer *execute_buffer, struct d3d_device *device)
HRESULT	d3d_vertex_buffer_create (struct d3d_vertex_buffer **buffer, struct ddraw *ddraw, D3DVERTEXBUFFERDESC *desc)
struct d3d_vertex_buffer *	unsafe_impl_from_IDirect3DVertexBuffer (IDirect3DVertexBuffer *iface)
struct d3d_vertex_buffer *	unsafe_impl_from_IDirect3DVertexBuffer7 (IDirect3DVertexBuffer7 *iface)
void	ddrawformat_from_wined3dformat (DDPIXELFORMAT *ddraw_format, enum wined3d_format_id wined3d_format)
BOOL	wined3d_colour_from_ddraw_colour (const DDPIXELFORMAT *pf, const struct ddraw_palette *palette, DWORD colour, struct wined3d_color *wined3d_colour)
enum wined3d_format_id	wined3dformat_from_ddrawformat (const DDPIXELFORMAT *format)
unsigned int	wined3dmapflags_from_ddrawmapflags (unsigned int flags)
void	DDRAW_dump_surface_desc (const DDSURFACEDESC2 *lpddsd)
void	dump_D3DMATRIX (const D3DMATRIX *mat)
void	DDRAW_dump_DDCAPS (const DDCAPS *lpcaps)
DWORD	get_flexible_vertex_size (DWORD d3dvtVertexType)
void	DDRAW_dump_DDSCAPS2 (const DDSCAPS2 *in)
void	DDRAW_dump_cooperativelevel (DWORD cooplevel)
void	DDSD_to_DDSD2 (const DDSURFACEDESC *in, DDSURFACEDESC2 *out)
void	DDSD2_to_DDSD (const DDSURFACEDESC2 *in, DDSURFACEDESC *out)
void	multiply_matrix (struct wined3d_matrix *dst, const struct wined3d_matrix *src1, const struct wined3d_matrix *src2)
static BOOL	format_is_compressed (const DDPIXELFORMAT *format)
static BOOL	format_is_paletteindexed (const DDPIXELFORMAT *fmt)
static BOOL	ddraw_surface_can_be_lost (const struct ddraw_surface *surface)
static struct wined3d_texture *	ddraw_surface_get_default_texture (struct ddraw_surface *surface, unsigned int flags)
static struct wined3d_texture *	ddraw_surface_get_draw_texture (struct ddraw_surface *surface, unsigned int flags)
static struct wined3d_texture *	ddraw_surface_get_any_texture (struct ddraw_surface *surface, unsigned int flags)
void	d3d_device_sync_surfaces (struct d3d_device *device)
void	d3d_device_apply_state (struct d3d_device *device, BOOL clear_state)
HRESULT	hr_ddraw_from_wined3d (HRESULT hr)
void	viewport_alloc_active_light_index (struct d3d_light *light)
void	viewport_free_active_light_index (struct d3d_light *light)

Variables
const struct wined3d_parent_ops	ddraw_null_wined3d_parent_ops
DWORD	force_refresh_rate
struct ddraw_handle_table	global_handle_table
const GUID	IID_D3DDEVICE_WineD3D

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 26 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 748 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 737 of file ddraw_private.h.

DDRAW_D3D_INITIALIZED

#define DDRAW_D3D_INITIALIZED   0x00000002

Definition at line 54 of file ddraw_private.h.

DDRAW_INITIALIZED

#define DDRAW_INITIALIZED   0x00000001

Definition at line 53 of file ddraw_private.h.

DDRAW_INVALID_HANDLE

#define DDRAW_INVALID_HANDLE   ~0U

Definition at line 282 of file ddraw_private.h.

DDRAW_MAX_ACTIVE_LIGHTS

#define DDRAW_MAX_ACTIVE_LIGHTS   32

Definition at line 70 of file ddraw_private.h.

DDRAW_MAX_TEXTURES

#define DDRAW_MAX_TEXTURES   8

Definition at line 71 of file ddraw_private.h.

DDRAW_NO3D

#define DDRAW_NO3D   0x00000008

Definition at line 56 of file ddraw_private.h.

DDRAW_RESTORE_MODE

#define DDRAW_RESTORE_MODE   0x00000004

Definition at line 55 of file ddraw_private.h.

DDRAW_SCL_DDRAW1

#define DDRAW_SCL_DDRAW1   0x00000010

Definition at line 57 of file ddraw_private.h.

DDRAW_SCL_RECURSIVE

#define DDRAW_SCL_RECURSIVE   0x00000020

Definition at line 58 of file ddraw_private.h.

DDRAW_STRIDE_ALIGNMENT

#define DDRAW_STRIDE_ALIGNMENT   8

Definition at line 61 of file ddraw_private.h.

DDRAW_SURFACE_LOCATION_DEFAULT

#define DDRAW_SURFACE_LOCATION_DEFAULT   0x00000001

Definition at line 159 of file ddraw_private.h.

DDRAW_SURFACE_LOCATION_DRAW

#define DDRAW_SURFACE_LOCATION_DRAW   0x00000002

Definition at line 160 of file ddraw_private.h.

DDRAW_SURFACE_READ

#define DDRAW_SURFACE_READ   0x00000001

Definition at line 663 of file ddraw_private.h.

DDRAW_SURFACE_RW

#define DDRAW_SURFACE_RW   (DDRAW_SURFACE_READ | DDRAW_SURFACE_WRITE)

Definition at line 665 of file ddraw_private.h.

DDRAW_SURFACE_WRITE

#define DDRAW_SURFACE_WRITE   0x00000002

Definition at line 664 of file ddraw_private.h.

DDRAW_SWAPPED

#define DDRAW_SWAPPED   0x00000040

Definition at line 59 of file ddraw_private.h.

DDRAW_WINDOW_CLASS_NAME

#define DDRAW_WINDOW_CLASS_NAME   "DirectDrawDeviceWnd"

Definition at line 140 of file ddraw_private.h.

DDRAW_WINED3D_FLAGS

#define DDRAW_WINED3D_FLAGS

Value:

        (WINED3D_LEGACY_DEPTH_BIAS | 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_NO_DRAW_INDIRECT)

Definition at line 63 of file ddraw_private.h.

DDRAW_WINED3D_SWAPCHAIN_FLAGS

#define DDRAW_WINED3D_SWAPCHAIN_FLAGS

Value:

        (WINED3D_SWAPCHAIN_ALLOW_MODE_SWITCH \
        | WINED3D_SWAPCHAIN_IMPLICIT | WINED3D_SWAPCHAIN_REGISTER_TOPMOST_TIMER)

Definition at line 67 of file ddraw_private.h.

FE

#define FE

(

x

)

{ x, #x }

Definition at line 724 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 615 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 612 of file ddraw_private.h.

MAX_COMPLEX_ATTACHED

#define MAX_COMPLEX_ATTACHED   6

Definition at line 200 of file ddraw_private.h.

ME

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

Definition at line 735 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 73 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 284 of file ddraw_private.h.

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

ddraw_viewport_version

enum ddraw_viewport_version

Enumerator
DDRAW_VIEWPORT_VERSION_NONE
DDRAW_VIEWPORT_VERSION_1
DDRAW_VIEWPORT_VERSION_2

Definition at line 501 of file ddraw_private.h.

{
    DDRAW_VIEWPORT_VERSION_NONE,
    DDRAW_VIEWPORT_VERSION_1,
    DDRAW_VIEWPORT_VERSION_2,
};

Function Documentation

d3d_device_apply_state()

void d3d_device_apply_state	(	struct d3d_device *	device,
		BOOL	clear_state
	)

Definition at line 3454 of file device.c.

{
    if (device->ddraw && device->ddraw->device_last_applied_state != device)
    {
        wined3d_stateblock_primary_dirtify_all_states(device->wined3d_device, device->state);
        device->ddraw->device_last_applied_state = device;
    }
    if (clear_state)
        wined3d_stateblock_apply_clear_state(device->state, device->wined3d_device);
    else
        wined3d_device_apply_stateblock(device->wined3d_device, device->state);
    d3d_device_sync_surfaces(device);
}

Referenced by d3d_device7_Clear(), d3d_device7_DrawIndexedPrimitive(), d3d_device7_DrawIndexedPrimitiveStrided(), d3d_device7_DrawIndexedPrimitiveVB(), d3d_device7_DrawPrimitive(), d3d_device7_DrawPrimitiveStrided(), and d3d_device7_DrawPrimitiveVB().

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 6959 of file device.c.

{
    struct d3d_device *object;
    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 (!(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 (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_OUTOFMEMORY;
    }
 
    if (!(object = calloc(1, sizeof(*object))))
    {
        ERR("Failed to allocate device memory.\n");
        return DDERR_OUTOFMEMORY;
    }
 
    if (FAILED(hr = d3d_device_init(object, ddraw, guid, target, rt_iface, version, outer_unknown)))
    {
        WARN("Failed to initialize device, hr %#lx.\n", hr);
        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_sync_surfaces()

void d3d_device_sync_surfaces

(

struct d3d_device *

device

)

Definition at line 3427 of file device.c.

{
    const struct wined3d_stateblock_state *state = device->stateblock_state;
    struct ddraw_surface *surface;
    unsigned int i, j;
 
    d3d_device_sync_rendertarget(device);
 
    if (!device->have_draw_textures)
        return;
 
    for (i = 0; i < ARRAY_SIZE(state->textures); ++i)
    {
        if (!state->textures[i])
            continue;
 
        j = 0;
        while ((surface = wined3d_texture_get_sub_resource_parent(state->textures[i], j)))
        {
            if (!surface->draw_texture)
                break;
            ddraw_surface_get_draw_texture(surface, DDRAW_SURFACE_READ);
            ++j;
        }
    }
}

Referenced by d3d_device_apply_state().

d3d_device_update_depth_stencil()

enum wined3d_depth_buffer_type d3d_device_update_depth_stencil

(

struct d3d_device *

device

)

Definition at line 6817 of file device.c.

{
    IDirectDrawSurface7 *depthStencil = NULL;
    IDirectDrawSurface7 *render_target;
    static DDSCAPS2 depthcaps = { DDSCAPS_ZBUFFER, 0, 0, {0} };
 
    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_context_set_depth_stencil_view(device->immediate_context, NULL);
        wined3d_stateblock_depth_buffer_changed(device->state);
        device->target_ds = NULL;
        return WINED3D_ZB_FALSE;
    }
 
    device->target_ds = impl_from_IDirectDrawSurface7(depthStencil);
    wined3d_device_context_set_depth_stencil_view(device->immediate_context,
            ddraw_surface_get_rendertarget_view(device->target_ds));
    wined3d_stateblock_depth_buffer_changed(device->state);
 
    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
	)

Definition at line 48 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;
 
    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_context_set_primitive_type(device->immediate_context, WINED3D_PT_POINTLIST, 0);
                wined3d_stateblock_set_stream_source(device->state, 0,
                        buffer->dst_vertex_buffer, 0, sizeof(D3DTLVERTEX));
                wined3d_stateblock_set_vertex_declaration(device->state,
                        ddraw_find_decl(device->ddraw, D3DFVF_TLVERTEX));
 
                d3d_device_apply_state(device, FALSE);
                for (i = 0; i < count; ++i)
                    wined3d_device_context_draw(device->immediate_context, p[i].wFirst, p[i].wCount, 0, 0);
 
                instr += sizeof(*p) * count;
                break;
            }
 
            case D3DOP_LINE:
                primitive_size = 2;
                wined3d_device_context_set_primitive_type(device->immediate_context, 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_context_set_primitive_type(device->immediate_context, 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_STATICDECL;
                    desc.bind_flags = WINED3D_BIND_INDEX_BUFFER;
                    desc.access = WINED3D_RESOURCE_ACCESS_GPU | 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->v1, ci->v2, ci->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->v3;
                            /* Drop through. */
                        case 2:
                            indices[(i * primitive_size) + 1] = ci->v2;
                            indices[(i * primitive_size)    ] = ci->v1;
                    }
                    instr += size;
                }
 
                wined3d_resource_unmap(wined3d_buffer_get_resource(buffer->index_buffer), 0);
 
                wined3d_stateblock_set_stream_source(device->state, 0,
                        buffer->dst_vertex_buffer, 0, sizeof(D3DTLVERTEX));
                wined3d_stateblock_set_vertex_declaration(device->state,
                        ddraw_find_decl(device->ddraw, D3DFVF_TLVERTEX));
                wined3d_stateblock_set_index_buffer(device->state, buffer->index_buffer, WINED3DFMT_R16_UINT);
                d3d_device_apply_state(device, FALSE);
                wined3d_device_context_draw_indexed(device->immediate_context, 0, index_pos, index_count, 0, 0);
 
                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;
                    struct wined3d_matrix *a, *b, *c;
 
                    a = ddraw_get_object(NULL, ci->hDestMatrix - 1, DDRAW_HANDLE_MATRIX);
                    b = ddraw_get_object(NULL, ci->hSrcMatrix1 - 1, DDRAW_HANDLE_MATRIX);
                    c = ddraw_get_object(NULL, ci->hSrcMatrix2 - 1, DDRAW_HANDLE_MATRIX);
 
                    if (!a || !b || !c)
                    {
                        ERR("Invalid matrix handle (a %#lx -> %p, b %#lx -> %p, c %#lx -> %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(NULL, ci->dwArg[0] - 1, DDRAW_HANDLE_MATRIX);
                    if (!m)
                    {
                        ERR("Invalid matrix handle %#lx.\n", ci->dwArg[0]);
                    }
                    else
                    {
                        if (ci->dtstTransformStateType == D3DTRANSFORMSTATE_WORLD)
                            device->world = ci->dwArg[0];
                        if (ci->dtstTransformStateType == D3DTRANSFORMSTATE_VIEW)
                            device->view = ci->dwArg[0];
                        if (ci->dtstTransformStateType == D3DTRANSFORMSTATE_PROJECTION)
                            device->proj = ci->dwArg[0];
                        IDirect3DDevice3_SetTransform(&device->IDirect3DDevice3_iface,
                                ci->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->dlstLightStateType, ci->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->drstRenderStateType, ci->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 %lu, flags %#lx.\n",
                            ci->wStart, ci->wDest, ci->dwCount, ci->dwFlags);
 
                    if (ci->dwFlags & D3DPROCESSVERTICES_UPDATEEXTENTS)
                        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_stateblock_set_stream_source(device->state, 0,
                                    buffer->src_vertex_buffer, buffer->src_vertex_pos * sizeof(D3DVERTEX), sizeof(D3DVERTEX));
                            wined3d_stateblock_set_render_state(device->state, WINED3D_RS_LIGHTING,
                                    op == D3DPROCESSVERTICES_TRANSFORMLIGHT && !!device->material);
                            wined3d_stateblock_set_vertex_declaration(device->state,
                                    ddraw_find_decl(device->ddraw, op == D3DPROCESSVERTICES_TRANSFORMLIGHT
                                    ? D3DFVF_VERTEX : D3DFVF_LVERTEX));
                            d3d_device_sync_surfaces(device);
                            wined3d_device_process_vertices(device->wined3d_device, device->state, 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_context_copy_sub_resource_region(device->immediate_context,
                                    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, 0);
                            break;
 
                        default:
                            FIXME("Unhandled vertex processing op %#lx.\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(NULL, ci->hDestTexture - 1, DDRAW_HANDLE_SURFACE)))
                    {
                        WARN("Invalid destination texture handle %#lx.\n", ci->hDestTexture);
                        continue;
                    }
                    if (!(src = ddraw_get_object(NULL, ci->hSrcTexture - 1, DDRAW_HANDLE_SURFACE)))
                    {
                        WARN("Invalid source texture handle %#lx.\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 %ld\n", ci->dwOffset);
                            if (ci->dwOffset) {
                                instr = (char*)current + ci->dwOffset;
                                break;
                            }
                        }
                    }
                    else
                    {
                        if (ci->bNegate)
                        {
                            TRACE(" Branch to %ld\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 756 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 = calloc(1, 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 250 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 498 of file material.c.

{
    struct d3d_material *material;
 
    if (!(material = calloc(1, 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 443 of file vertexbuffer.c.

{
    struct d3d_vertex_buffer *buffer;
    HRESULT hr = D3D_OK;
 
    TRACE("Vertex buffer description:\n");
    TRACE("    dwSize %lu\n", desc->dwSize);
    TRACE("    dwCaps %#lx\n", desc->dwCaps);
    TRACE("    FVF %#lx\n", desc->dwFVF);
    TRACE("    dwNumVertices %lu\n", desc->dwNumVertices);
 
    if (!(buffer = calloc(1, 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;
 
    /* ddraw4 vertex buffers ignore DISCARD and NOOVERWRITE, even on
     * pretransformed geometry, which means that a GPU-based buffer cannot
     * perform well.
     *
     * While at least one contemporaneous card (Geforce 4) does seem to show a
     * difference in its performance characteristics based on whether
     * D3DVBCAPS_SYSTEMMEMORY is set, it also doesn't *improve* performance to
     * use a non-SYSTEMMEMORY buffer with ddraw4. For wined3d it should always
     * be better to use sysmem.
     *
     * This improves performance in Prince of Persia 3D. */
    buffer->sysmem = ((buffer->Caps & D3DVBCAPS_SYSTEMMEMORY) || buffer->version < 7);
 
    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 %#lx.\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 %#lx.\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
        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 1232 of file viewport.c.

{
    viewport->IDirect3DViewport3_iface.lpVtbl = &d3d_viewport_vtbl;
    viewport->ref = 1;
    viewport->ddraw = ddraw;
    viewport->version = DDRAW_VIEWPORT_VERSION_NONE;
    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 138 of file main.c.

{
    struct ddraw_handle_entry *entry;
 
    if (!t)
        t = &global_handle_table;
 
    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 %#lx (%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 = 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 381 of file clipper.c.

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

Referenced by DirectDrawCreateClipper().

ddraw_clipper_is_valid()

BOOL ddraw_clipper_is_valid

(

const struct ddraw_clipper *

clipper

)

Definition at line 33 of file clipper.c.

{
    /* Native is very lenient when you invoke the clipper methods with a clipper pointer that
     * points to something that is either not accessible or not a clipper, or if you break
     * a clipper after assigning it to a surface. Deus Ex: Goty depends on this. */
 
    if (IsBadReadPtr(clipper, sizeof(*clipper)))
    {
        WARN("The application gave us an invalid clipper pointer %p.\n", clipper);
        return FALSE;
    }
    if (clipper->IDirectDrawClipper_iface.lpVtbl != &ddraw_clipper_vtbl)
    {
        WARN("The clipper vtable is modified: %p, expected %p.\n",
                clipper->IDirectDrawClipper_iface.lpVtbl, &ddraw_clipper_vtbl);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by ddraw_clipper_AddRef(), ddraw_clipper_GetClipList(), ddraw_clipper_GetHWnd(), ddraw_clipper_Initialize(), ddraw_clipper_IsClipListChanged(), ddraw_clipper_QueryInterface(), ddraw_clipper_Release(), ddraw_clipper_SetClipList(), ddraw_clipper_SetHWnd(), ddraw_surface7_GetClipper(), ddraw_surface7_SetClipper(), ddraw_surface_blt_clipped(), and ddraw_surface_wined3d_object_destroyed().

DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1()

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

Definition at line 953 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 943 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->dwCaps4 = 0;
}

Referenced by ddraw2_GetAvailableVidMem().

ddraw_d3dcaps1_from_7()

void ddraw_d3dcaps1_from_7	(	D3DDEVICEDESC *	caps1,
		D3DDEVICEDESC7 *	caps7
	)

Definition at line 1203 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;
 
    /* This value is zero on all Windows drivers we have seen so far. */
    caps1->dwMaxBufferSize = 0;
 
    /* AMD GPUs on Windows XP and newer report 1024 for HAL devices.
     * Nvidia GPUs report 65534. On Windows 9x we have seen 2048 on
     * AMD cards and 32768 on Nvidia. The API defined limit is 65536
     * because ddraw only supports 16 bit indices.
     *
     * Some games, for example Prince of Persia 3D (bug 44863), create a
     * vertex buffer to hold as many vertices as we report here. The
     * game requests a video memory buffer, maps it, writes a handful
     * of vertices and draws. Because IDirect3DVertexBuffer::Lock does
     * not allow passing a range, and prior to d3d7 doesn't support
     * NOOVERWRITE/DISCARD, the upload becomes slow if the buffer is too
     * large. So we don't want to report a value that's too high here.
     *
     * Why 2048? Windows 9x was the contemporaneous system when d3d 1-4
     * titles were written.
     *
     * Regardless of this value, we put ddraw4 vertex buffers into
     * system memory because games are using them poorly. This mitigates
     * negative effects of a large vertex count.
     *
     * Windows doesn't enforce this limit. A larger vertex buffer can
     * be created and used in draws. More vertices than dwMaxVertexCount
     * can be rendered in one draw call. SetExecuteData with a vertex
     * count exceeding dwMaxVertexCount succeeds too. */
    caps1->dwMaxVertexCount = 2048;
 
    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(), d3d_device3_GetCaps(), and ddraw_find_device().

DDRAW_dump_cooperativelevel()

void DDRAW_dump_cooperativelevel

(

DWORD

cooplevel

)

Definition at line 960 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 982 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 : %lu\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 : %lu\n", lpcaps->dwNumFourCCCodes);
    TRACE(" - dwCurrVisibleOverlays : %lu\n", lpcaps->dwCurrVisibleOverlays);
    TRACE(" - dwMinOverlayStretch : %lu\n", lpcaps->dwMinOverlayStretch);
    TRACE(" - dwMaxOverlayStretch : %lu\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 710 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 857 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, lPitch),
        ME(DDSD_LINEARSIZE, DDRAW_dump_DWORD, dwLinearSize),
        ME(DDSD_BACKBUFFERCOUNT, DDRAW_dump_DWORD, dwBackBufferCount),
        ME(DDSD_MIPMAPCOUNT, DDRAW_dump_DWORD, dwMipMapCount),
        ME(DDSD_REFRESHRATE, DDRAW_dump_DWORD, dwRefreshRate),
        ME(DDSD_ALPHABITDEPTH, DDRAW_dump_DWORD, dwAlphaBitDepth),
        ME(DDSD_LPSURFACE, DDRAW_dump_PTR, lpSurface),
        ME(DDSD_CKDESTOVERLAY, DDRAW_dump_DDCOLORKEY, 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, 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 4917 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 %08lx... ", 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 = 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 184 of file main.c.

{
    struct ddraw_handle_entry *entry;
    void *object;
 
    if (!t)
        t = &global_handle_table;
 
    if (handle == DDRAW_INVALID_HANDLE || handle >= t->entry_count)
    {
        WARN("Invalid handle %#lx passed.\n", handle);
        return NULL;
    }
 
    entry = &t->entries[handle];
    if (entry->type != type)
    {
        WARN("Handle %#lx (%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 1287 of file ddraw.c.

{
    struct wined3d_caps 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_adapter, WINED3D_DEVICE_TYPE_HAL, &wined3d_caps);
    wined3d_mutex_unlock();
    if (FAILED(hr))
    {
        WARN("Failed to get device caps, hr %#lx.\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_ZBUFFERLESSHSR    | D3DPRASTERCAPS_FOGRANGE             | D3DPRASTERCAPS_ANISOTROPY           |
        D3DPRASTERCAPS_WBUFFER           | D3DPRASTERCAPS_TRANSLUCENTSORTINDEPENDENT | D3DPRASTERCAPS_WFOG           |
        D3DPRASTERCAPS_ZFOG | WINED3DPRASTERCAPS_DEPTHBIAS);
    if (caps->dpcLineCaps.dwRasterCaps & WINED3DPRASTERCAPS_DEPTHBIAS)
        caps->dpcLineCaps.dwRasterCaps = (caps->dpcLineCaps.dwRasterCaps | D3DPRASTERCAPS_ZBIAS)
                & ~WINED3DPRASTERCAPS_DEPTHBIAS;
    if (wined3d_caps.LineCaps & WINED3DLINECAPS_ANTIALIAS)
        caps->dpcLineCaps.dwRasterCaps |= D3DPRASTERCAPS_ANTIALIASEDGES;
 
    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(), d3d7_EnumDevices(), d3d_device3_GetCaps(), d3d_device7_GetCaps(), and ddraw_find_device().

ddraw_get_object()

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

Definition at line 213 of file main.c.

{
    struct ddraw_handle_entry *entry;
 
    if (!t)
        t = &global_handle_table;
 
    if (handle == DDRAW_INVALID_HANDLE || handle >= t->entry_count)
    {
        WARN("Invalid handle %#lx passed.\n", handle);
        return NULL;
    }
 
    entry = &t->entries[handle];
    if (entry->type != type)
    {
        WARN("Handle %#lx (%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 132 of file main.c.

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

Referenced by d3d_device_init(), d3d_device_inner_Release(), and DllMain().

ddraw_handle_table_init()

BOOL ddraw_handle_table_init	(	struct ddraw_handle_table *	t,
		UINT	initial_size
	)

Definition at line 118 of file main.c.

{
    if (!(t->entries = calloc(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(), and DllMain().

ddraw_init()

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

Definition at line 5079 of file ddraw.c.

{
    struct wined3d_caps caps;
    HRESULT hr;
 
    static const enum wined3d_feature_level feature_levels[] =
    {
        WINED3D_FEATURE_LEVEL_7,
        WINED3D_FEATURE_LEVEL_6,
        WINED3D_FEATURE_LEVEL_5,
    };
 
    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->state_parent.ops = &ddraw_swapchain_state_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 (!(ddraw->wined3d_adapter = wined3d_get_adapter(ddraw->wined3d, WINED3DADAPTER_DEFAULT)))
    {
        WARN("Failed to get the default wined3d adapter.\n");
        wined3d_decref(ddraw->wined3d);
        return E_FAIL;
    }
 
    if (!(ddraw->wined3d_output = wined3d_adapter_get_output(ddraw->wined3d_adapter, 0)))
    {
        WARN("Failed to get the default wined3d output.\n");
        wined3d_decref(ddraw->wined3d);
        return E_FAIL;
    }
 
    if (FAILED(hr = wined3d_get_device_caps(ddraw->wined3d_adapter, device_type, &caps)))
    {
        ERR("Failed to get device caps, hr %#lx.\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, ddraw->wined3d_adapter, device_type,
            NULL, 0, DDRAW_STRIDE_ALIGNMENT, feature_levels, ARRAY_SIZE(feature_levels),
            &ddraw->device_parent, &ddraw->wined3d_device)))
    {
        WARN("Failed to create a wined3d device, hr %#lx.\n", hr);
        wined3d_decref(ddraw->wined3d);
        return hr;
    }
    ddraw->immediate_context = wined3d_device_get_immediate_context(ddraw->wined3d_device);
 
    list_init(&ddraw->surface_list);
    list_init(&ddraw->d3ddevice_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 256 of file palette.c.

{
    unsigned int entry_count;
    DWORD wined3d_flags = 0;
    HRESULT hr;
 
    if ((entry_count = palette_size(flags)) == ~0u)
    {
        WARN("Invalid flags %#lx.\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 %#lx.\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 147 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_can_be_lost()

static BOOL ddraw_surface_can_be_lost ( const struct ddraw_surface *  surface )

inlinestatic

Definition at line 650 of file ddraw_private.h.

{
    DWORD caps = surface->surface_desc.ddsCaps.dwCaps;
 
    /* Testing with DDCREATE_EMULATIONONLY showed that primary surfaces and Z buffers can
     * be lost even if created with explicit DDCAPS_SYSTEMMEMORY. Textures can or cannot be lost
     * depending on whether _SYSTEMMEMORY was given explicitly by the application. */
    if (!(caps & DDSCAPS_SYSTEMMEMORY) || caps & (DDSCAPS_PRIMARYSURFACE | DDSCAPS_ZBUFFER))
        return TRUE;
 
    return surface->sysmem_fallback;
}

Referenced by ddraw_surface7_Restore(), ddraw_surface_is_lost(), and ddraw_update_lost_surfaces().

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 6535 of file surface.c.

{
    DDPIXELFORMAT wined3d_display_mode_format;
    struct ddraw_surface *root, **attach;
    struct wined3d_display_mode mode;
    struct ddraw_texture *texture;
    BOOL sysmem_fallback = FALSE;
    unsigned int layers = 1;
    DDSURFACEDESC2 *desc;
    bool reserve_memory;
    UINT levels, i;
    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 = malloc(sizeof(*texture))))
        return E_OUTOFMEMORY;
 
    texture->texture_memory = NULL;
    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_COMPLEX)
            && !(desc->ddsCaps.dwCaps & (DDSCAPS_FLIP | DDSCAPS_MIPMAP))
            && !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP))
    {
        WARN("DDSCAPS_COMPLEX specified for a surface which is neither flippable, mipmapped, nor a cubemap.\n");
        free(texture);
        return DDERR_INVALIDCAPS;
    }
 
    if ((desc->dwFlags & DDSD_MIPMAPCOUNT) && !(desc->ddsCaps.dwCaps & DDSCAPS_COMPLEX))
    {
        /* This is illegal even if there is only one mipmap level. */
        WARN("DDSD_MIPMAPCOUNT specified without DDSCAPS_COMPLEX.\n");
        free(texture);
        return DDERR_INVALIDCAPS;
    }
 
    if (desc->ddsCaps.dwCaps & DDSCAPS_FLIP)
    {
        if (!(desc->dwFlags & DDSD_BACKBUFFERCOUNT) || !desc->dwBackBufferCount)
        {
            WARN("Tried to create a flippable surface without any back buffers.\n");
            free(texture);
            return DDERR_INVALIDCAPS;
        }
 
        if (!(desc->ddsCaps.dwCaps & DDSCAPS_COMPLEX))
        {
            WARN("Tried to create a flippable surface without DDSCAPS_COMPLEX.\n");
            free(texture);
            return DDERR_INVALIDCAPS;
        }
 
        if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
        {
            WARN("Tried to create a flippable cubemap.\n");
            free(texture);
            return DDERR_INVALIDPARAMS;
        }
 
        if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
        {
            FIXME("Flippable textures not implemented.\n");
            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;
            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");
            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");
            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");
            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");
        free(texture);
        return DDERR_INVALIDCAPS;
    }
 
    if ((desc->ddsCaps.dwCaps & (DDSCAPS_ALLOCONLOAD | DDSCAPS_MIPMAP))
            && !(desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE))
    {
        WARN("Caps %#lx require DDSCAPS_TEXTURE.\n", desc->ddsCaps.dwCaps);
        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");
        free(texture);
        return DDERR_INVALIDCAPS;
    }
 
    if ((desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
            && !(desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP_ALLFACES))
    {
        WARN("Cube map without faces requested.\n");
        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");
            free(texture);
            return DDERR_INVALIDCAPS;
        }
        if (desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY))
        {
            WARN("DDSCAPS2_TEXTUREMANAGE used with DDSCAPS_VIDEOMEMORY "
                    "or DDSCAPS_SYSTEMMEMORY, returning DDERR_INVALIDCAPS.\n");
            free(texture);
            return DDERR_INVALIDCAPS;
        }
    }
 
    if (desc->ddsCaps.dwCaps & DDSCAPS_WRITEONLY
            && !(desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE)))
    {
        WARN("DDSCAPS_WRITEONLY used without DDSCAPS2_TEXTUREMANAGE, returning DDERR_INVALIDCAPS.\n");
        free(texture);
        return DDERR_INVALIDCAPS;
    }
 
    if (FAILED(hr = wined3d_output_get_display_mode(ddraw->wined3d_output, &mode, NULL)))
    {
        ERR("Failed to get display mode, hr %#lx.\n", hr);
        free(texture);
        return hr_ddraw_from_wined3d(hr);
    }
 
    wined3d_display_mode_format.dwSize = sizeof(wined3d_display_mode_format);
    ddrawformat_from_wined3dformat(&wined3d_display_mode_format, mode.format_id);
 
    /* No pixelformat given? Use the current screen format. */
    if (!(desc->dwFlags & DDSD_PIXELFORMAT))
    {
        desc->dwFlags |= DDSD_PIXELFORMAT;
        desc->ddpfPixelFormat = wined3d_display_mode_format;
    }
 
    /* 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");
            free(texture);
            return DDERR_INVALIDPARAMS;
        }
 
        desc->dwFlags |= DDSD_WIDTH | DDSD_HEIGHT;
        desc->dwWidth = mode.width;
        desc->dwHeight = mode.height;
    }
 
    if (!desc->dwWidth || !desc->dwHeight)
    {
        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, FALSE)))
            {
                ERR("Failed to reset device.\n");
                free(texture);
                return hr_ddraw_from_wined3d(hr);
            }
        }
    }
 
    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->dwMipMapCount)
                {
                    free(texture);
                    return DDERR_INVALIDPARAMS;
                }
            }
            else
            {
                /* Undocumented feature: Create sublevels until either the
                 * width or the height is 1. */
                if (version == 7)
                    desc->dwMipMapCount = wined3d_log2i(max(desc->dwWidth, desc->dwHeight)) + 1;
                else
                    desc->dwMipMapCount = wined3d_log2i(min(desc->dwWidth, desc->dwHeight)) + 1;
            }
        }
        else
        {
            desc->dwMipMapCount = 1;
        }
 
        desc->dwFlags |= DDSD_MIPMAPCOUNT;
        levels = desc->dwMipMapCount;
    }
    else
    {
        levels = 1;
    }
 
    if (!(desc->ddsCaps.dwCaps & (DDSCAPS_VIDEOMEMORY | DDSCAPS_SYSTEMMEMORY)))
    {
        if (!(desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE)))
        {
            unsigned int bind_flags = 0;
            DWORD usage = 0;
 
            if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
            {
                usage |= WINED3DUSAGE_LEGACY_CUBEMAP;
                bind_flags |= WINED3D_BIND_SHADER_RESOURCE;
            }
            else if (desc->ddsCaps.dwCaps & DDSCAPS_TEXTURE)
            {
                bind_flags |= WINED3D_BIND_SHADER_RESOURCE;
            }
 
            if (desc->ddsCaps.dwCaps & DDSCAPS_ZBUFFER)
                bind_flags |= WINED3D_BIND_DEPTH_STENCIL;
            else if (desc->ddsCaps.dwCaps & DDSCAPS_3DDEVICE)
                bind_flags |= WINED3D_BIND_RENDER_TARGET;
 
            if (!(ddraw->flags & DDRAW_NO3D) && SUCCEEDED(hr = wined3d_check_device_format(ddraw->wined3d,
                    ddraw->wined3d_adapter, WINED3D_DEVICE_TYPE_HAL, mode.format_id,
                    usage, bind_flags, WINED3D_RTYPE_TEXTURE_2D, wined3dformat_from_ddrawformat(&desc->ddpfPixelFormat))))
            {
                desc->ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
            }
            else
            {
                desc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
                sysmem_fallback = TRUE;
            }
        }
        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");
        free(texture);
        return DDERR_NOOVERLAYHW;
    }
 
    if (desc->ddsCaps.dwCaps2 & (DDSCAPS2_TEXTUREMANAGE | DDSCAPS2_D3DTEXTUREMANAGE))
        desc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
 
    if (desc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)
        desc->ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM;
 
    if (desc->dwFlags & DDSD_LPSURFACE)
    {
        if (!(desc->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY))
        {
            WARN("User memory surfaces should not be GPU accessible.\n");
            free(texture);
            return DDERR_INVALIDCAPS;
        }
 
        if (version < 4)
        {
            WARN("User memory surfaces not supported before version 4.\n");
            free(texture);
            return DDERR_INVALIDPARAMS;
        }
 
        if (!desc->lpSurface)
        {
            WARN("NULL surface memory pointer specified.\n");
            free(texture);
            return DDERR_INVALIDPARAMS;
        }
 
        if (format_is_compressed(&desc->ddpfPixelFormat))
        {
            if (version != 4 && (desc->dwFlags & DDSD_PITCH))
            {
                WARN("Pitch specified on a compressed user memory surface.\n");
                free(texture);
                return DDERR_INVALIDPARAMS;
            }
 
            if (!(desc->dwFlags & (DDSD_LINEARSIZE | DDSD_PITCH)))
            {
                WARN("Compressed user memory surfaces should explicitly specify the linear size.\n");
                free(texture);
                return DDERR_INVALIDPARAMS;
            }
        }
        else
        {
            if (!(desc->dwFlags & DDSD_PITCH))
            {
                WARN("User memory surfaces should explicitly specify the pitch.\n");
                free(texture);
                return DDERR_INVALIDPARAMS;
            }
        }
    }
 
    if (((desc->dwFlags & DDSD_CKDESTOVERLAY)
            && desc->ddckCKDestOverlay.dwColorSpaceLowValue != desc->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");
        free(texture);
        return DDERR_NOCOLORKEYHW;
    }
 
    if ((ddraw->flags & DDRAW_NO3D) && (desc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY))
    {
        WARN("Video memory surfaces not supported without 3D support.\n");
        free(texture);
        return DDERR_NODIRECTDRAWHW;
    }
 
    if (desc->ddsCaps.dwCaps2 & DDSCAPS2_CUBEMAP)
        layers = 6;
 
    reserve_memory = !(desc->dwFlags & DDSD_LPSURFACE)
            && desc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY
            && wined3d_display_mode_format.dwRGBBitCount <= 16;
 
    if (FAILED(hr = ddraw_texture_init(texture, ddraw, layers, levels, sysmem_fallback, reserve_memory)))
    {
        WARN("Failed to create wined3d texture, hr %#lx.\n", hr);
        free(texture);
        return hr_ddraw_from_wined3d(hr);
    }
 
    root = texture->root;
    root->is_root = TRUE;
 
    if (desc->dwFlags & DDSD_BACKBUFFERCOUNT)
    {
        unsigned int count = desc->dwBackBufferCount;
        struct ddraw_surface *last = root;
 
        attach = &last->complex_array[0];
        for (i = 0; i < count; ++i)
        {
            if (!(texture = malloc(sizeof(*texture))))
            {
                hr = E_OUTOFMEMORY;
                goto fail;
            }
 
            texture->texture_memory = NULL;
            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->dwBackBufferCount = 0;
 
            if (FAILED(hr = ddraw_texture_init(texture, ddraw, 1, 1, sysmem_fallback, reserve_memory)))
            {
                free(texture);
                hr = hr_ddraw_from_wined3d(hr);
                goto fail;
            }
 
            last = texture->root;
 
            *attach = last;
            attach = &last->complex_array[0];
        }
        *attach = root;
    }
 
    if (surface_desc->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    {
        ddraw->primary = root;
        ddraw->gdi_surface = root->wined3d_texture;
    }
    *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_any_texture()

static struct wined3d_texture * ddraw_surface_get_any_texture ( struct ddraw_surface *  surface, unsigned int  flags  )

inlinestatic

Definition at line 704 of file ddraw_private.h.

{
    if ((surface->texture_location & DDRAW_SURFACE_LOCATION_DEFAULT)
            || (surface->surface_desc.ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY))
        return ddraw_surface_get_default_texture(surface, flags);
 
    assert(surface->texture_location & DDRAW_SURFACE_LOCATION_DRAW);
    return ddraw_surface_get_draw_texture(surface, flags);
}

Referenced by copy_mipmap_chain(), ddraw_surface7_BltFast(), ddraw_surface_blt(), and ddraw_surface_update_frontbuffer().

ddraw_surface_get_default_texture()

static struct wined3d_texture * ddraw_surface_get_default_texture ( struct ddraw_surface *  surface, unsigned int  flags  )

inlinestatic

Definition at line 667 of file ddraw_private.h.

{
    if (surface->draw_texture)
    {
        if (flags & DDRAW_SURFACE_READ && !(surface->texture_location & DDRAW_SURFACE_LOCATION_DEFAULT))
        {
            wined3d_device_context_copy_sub_resource_region(surface->ddraw->immediate_context,
                    wined3d_texture_get_resource(surface->wined3d_texture), surface->sub_resource_idx, 0, 0, 0,
                    wined3d_texture_get_resource(surface->draw_texture), surface->sub_resource_idx, NULL, 0);
            surface->texture_location |= DDRAW_SURFACE_LOCATION_DEFAULT;
        }
 
        if (flags & DDRAW_SURFACE_WRITE)
            surface->texture_location = DDRAW_SURFACE_LOCATION_DEFAULT;
    }
    return surface->wined3d_texture;
}

Referenced by d3d_texture2_Load(), ddraw_surface1_Unlock(), ddraw_surface7_GetDC(), ddraw_surface7_ReleaseDC(), ddraw_surface_blt(), ddraw_surface_get_any_texture(), ddraw_surface_update_frontbuffer(), and surface_lock().

ddraw_surface_get_draw_texture()

static struct wined3d_texture * ddraw_surface_get_draw_texture ( struct ddraw_surface *  surface, unsigned int  flags  )

inlinestatic

Definition at line 685 of file ddraw_private.h.

{
    if (!surface->draw_texture)
        return surface->wined3d_texture;
 
    if (flags & DDRAW_SURFACE_READ && !(surface->texture_location & DDRAW_SURFACE_LOCATION_DRAW))
    {
        wined3d_device_context_copy_sub_resource_region(surface->ddraw->immediate_context,
                wined3d_texture_get_resource(surface->draw_texture), surface->sub_resource_idx, 0, 0, 0,
                wined3d_texture_get_resource(surface->wined3d_texture), surface->sub_resource_idx, NULL, 0);
        surface->texture_location |= DDRAW_SURFACE_LOCATION_DRAW;
    }
 
    if (flags & DDRAW_SURFACE_WRITE)
        surface->texture_location = DDRAW_SURFACE_LOCATION_DRAW;
 
    return surface->draw_texture;
}

Referenced by d3d_device_sync_rendertarget(), d3d_device_sync_surfaces(), ddraw_surface_blt(), and ddraw_surface_get_any_texture().

ddraw_surface_get_rendertarget_view()

struct wined3d_rendertarget_view * ddraw_surface_get_rendertarget_view

(

struct ddraw_surface *

surface

)

Definition at line 7053 of file surface.c.

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

Referenced by d3d_device7_SetViewport(), d3d_device_init(), d3d_device_set_render_target(), d3d_device_sync_rendertarget(), d3d_device_update_depth_stencil(), d3d_viewport_SetViewport(), d3d_viewport_SetViewport2(), ddraw_surface1_Flip(), ddraw_surface7_SetSurfaceDesc(), and ddraw_surface_blt().

ddraw_surface_update_frontbuffer()

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

Definition at line 61 of file surface.c.

{
    struct wined3d_texture *dst_texture, *wined3d_texture;
    struct ddraw *ddraw = surface->ddraw;
    HDC surface_dc, screen_dc;
    int x, y, w, h;
    HRESULT hr;
    BOOL ret;
    RECT r;
 
    TRACE("surface %p, rect %s, read %#x, swap_interval %u.\n",
            surface, wine_dbgstr_rect(rect), read, swap_interval);
 
    if (ddraw->flags & DDRAW_SWAPPED && !read)
    {
        ddraw->flags &= ~DDRAW_SWAPPED;
        rect = NULL;
    }
 
    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 (!read && TRACE_ON(fps))
    {
        DWORD time = GetTickCount();
        ++ddraw->frames;
 
        /* every 1.5 seconds */
        if (time - ddraw->prev_frame_time > 1500)
        {
            TRACE_(fps)("%p @ approx %.2ffps\n",
                    ddraw, 1000.0 * ddraw->frames / (time - ddraw->prev_frame_time));
            ddraw->prev_frame_time = time;
            ddraw->frames = 0;
        }
    }
 
    /* The interaction between ddraw and GDI drawing is not all that well
     * documented, and somewhat arcane. In ddraw exclusive mode, GDI draws
     * seemingly go to the *original* frontbuffer/primary surface, while ddraw
     * draws/flips go to the *current* frontbuffer surface. The bottom line is
     * that if the current frontbuffer is not the GDI frontbuffer, and there's
     * e.g. a popup window in front of the ddraw swapchain window, we can't
     * use wined3d_swapchain_present() to get the ddraw contents to the screen
     * while in exclusive mode, since it would get obscured by the popup
     * window. On the other hand, if the current frontbuffer *is* the GDI
     * frontbuffer, that's what's supposed to happen; the popup should obscure
     * (part of) the ddraw swapchain window.
     *
     * This affects the "Deer Hunter" demo, which uses a popup window and GDI
     * draws to draw part of the user interface. See also the "fswindow"
     * sample is the DirectX 7 SDK. */
    if (ddraw->swapchain_window && (!(ddraw->cooperative_level & DDSCL_EXCLUSIVE)
            || ddraw->swapchain_window == GetForegroundWindow() || ddraw_gdi_is_front(ddraw)))
    {
        /* Nothing to do, we control the frontbuffer, or at least the parts we
         * care about. */
        if (read)
            return DD_OK;
 
        if (swap_interval)
            dst_texture = wined3d_swapchain_get_back_buffer(ddraw->wined3d_swapchain, 0);
        else
            dst_texture = wined3d_swapchain_get_front_buffer(ddraw->wined3d_swapchain);
 
        if (SUCCEEDED(hr = wined3d_device_context_blt(ddraw->immediate_context, dst_texture, 0, rect,
                ddraw_surface_get_any_texture(surface, DDRAW_SURFACE_READ), surface->sub_resource_idx, rect, 0,
                NULL, WINED3D_TEXF_POINT)) && swap_interval)
        {
            hr = wined3d_swapchain_present(ddraw->wined3d_swapchain, rect, rect, NULL, swap_interval, 0);
            ddraw->flags |= DDRAW_SWAPPED;
        }
        return hr;
    }
 
    wined3d_texture = ddraw_surface_get_default_texture(surface, read ? (rect ? DDRAW_SURFACE_RW : DDRAW_SURFACE_WRITE)
            : DDRAW_SURFACE_READ);
 
    if (FAILED(hr = wined3d_texture_get_dc(wined3d_texture, surface->sub_resource_idx, &surface_dc)))
    {
        ERR("Failed to get surface DC, hr %#lx.\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(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(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_surface1_Flip(), ddraw_surface1_Unlock(), ddraw_surface7_BltFast(), ddraw_surface7_GetDC(), ddraw_surface7_ReleaseDC(), 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 5031 of file ddraw.c.

{
    struct ddraw_surface *surface;
 
    /* Railroad Tycoon 2 tries to restore surfaces from within a
     * WM_QUERYNEWPALETTE message handler and expects it to succeed. We
     * haven't received the WM_ACTIVATEAPP message by that point, so the
     * device state is still DDRAW_DEVICE_STATE_LOST, even though we are in
     * the foreground. */
    if (ddraw->device_state == DDRAW_DEVICE_STATE_LOST)
    {
        HWND window = ddraw->focuswindow ? ddraw->focuswindow : ddraw->dest_window;
 
        if (window && GetForegroundWindow() == window)
            ddraw->device_state = DDRAW_DEVICE_STATE_NOT_RESTORED;
    }
 
    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 = ddraw_surface_can_be_lost(surface);
    }
    ddraw->device_state = DDRAW_DEVICE_STATE_OK;
}

Referenced by ddraw_surface7_Restore(), and ddraw_texture_init().

ddrawformat_from_wined3dformat()

void ddrawformat_from_wined3dformat	(	DDPIXELFORMAT *	ddraw_format,
		enum wined3d_format_id	wined3d_format
	)

Definition at line 30 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->dwRGBBitCount = 24;
            DDPixelFormat->dwRBitMask = 0x00ff0000;
            DDPixelFormat->dwGBitMask = 0x0000ff00;
            DDPixelFormat->dwBBitMask = 0x000000ff;
            DDPixelFormat->dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_B8G8R8A8_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwRGBBitCount = 32;
            DDPixelFormat->dwRBitMask = 0x00ff0000;
            DDPixelFormat->dwGBitMask = 0x0000ff00;
            DDPixelFormat->dwBBitMask = 0x000000ff;
            DDPixelFormat->dwRGBAlphaBitMask = 0xff000000;
            break;
 
        case WINED3DFMT_B8G8R8X8_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwRGBBitCount = 32;
            DDPixelFormat->dwRBitMask = 0x00ff0000;
            DDPixelFormat->dwGBitMask = 0x0000ff00;
            DDPixelFormat->dwBBitMask = 0x000000ff;
            DDPixelFormat->dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_R8G8B8X8_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwRGBBitCount = 32;
            DDPixelFormat->dwRBitMask = 0x000000ff;
            DDPixelFormat->dwGBitMask = 0x0000ff00;
            DDPixelFormat->dwBBitMask = 0x00ff0000;
            DDPixelFormat->dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_B5G6R5_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwRGBBitCount = 16;
            DDPixelFormat->dwRBitMask = 0xF800;
            DDPixelFormat->dwGBitMask = 0x07E0;
            DDPixelFormat->dwBBitMask = 0x001F;
            DDPixelFormat->dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_B5G5R5X1_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwRGBBitCount = 16;
            DDPixelFormat->dwRBitMask = 0x7C00;
            DDPixelFormat->dwGBitMask = 0x03E0;
            DDPixelFormat->dwBBitMask = 0x001F;
            DDPixelFormat->dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_B5G5R5A1_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwRGBBitCount = 16;
            DDPixelFormat->dwRBitMask = 0x7C00;
            DDPixelFormat->dwGBitMask = 0x03E0;
            DDPixelFormat->dwBBitMask = 0x001F;
            DDPixelFormat->dwRGBAlphaBitMask = 0x8000;
            break;
 
        case WINED3DFMT_B4G4R4A4_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwRGBBitCount = 16;
            DDPixelFormat->dwRBitMask = 0x0F00;
            DDPixelFormat->dwGBitMask = 0x00F0;
            DDPixelFormat->dwBBitMask = 0x000F;
            DDPixelFormat->dwRGBAlphaBitMask = 0xF000;
            break;
 
        case WINED3DFMT_B2G3R3_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwRGBBitCount = 8;
            DDPixelFormat->dwRBitMask = 0xE0;
            DDPixelFormat->dwGBitMask = 0x1C;
            DDPixelFormat->dwBBitMask = 0x03;
            DDPixelFormat->dwLuminanceAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_P8_UINT:
            DDPixelFormat->dwFlags = DDPF_PALETTEINDEXED8 | DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwRGBBitCount = 8;
            DDPixelFormat->dwRBitMask = 0x00;
            DDPixelFormat->dwGBitMask = 0x00;
            DDPixelFormat->dwBBitMask = 0x00;
            break;
 
        case WINED3DFMT_A8_UNORM:
            DDPixelFormat->dwFlags = DDPF_ALPHA;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwAlphaBitDepth = 8;
            DDPixelFormat->dwRBitMask = 0x0;
            DDPixelFormat->dwZBitMask = 0x0;
            DDPixelFormat->dwStencilBitMask = 0x0;
            DDPixelFormat->dwLuminanceAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_B2G3R3A8_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwRGBBitCount = 16;
            DDPixelFormat->dwRBitMask = 0x00E0;
            DDPixelFormat->dwGBitMask = 0x001C;
            DDPixelFormat->dwBBitMask = 0x0003;
            DDPixelFormat->dwRGBAlphaBitMask = 0xFF00;
            break;
 
        case WINED3DFMT_B4G4R4X4_UNORM:
            DDPixelFormat->dwFlags = DDPF_RGB;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwRGBBitCount = 16;
            DDPixelFormat->dwRBitMask = 0x0F00;
            DDPixelFormat->dwGBitMask = 0x00F0;
            DDPixelFormat->dwBBitMask = 0x000F;
            DDPixelFormat->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->dwZBufferBitDepth = 16;
            DDPixelFormat->dwStencilBitDepth = 0;
            DDPixelFormat->dwZBitMask = 0x0000FFFF;
            DDPixelFormat->dwStencilBitMask = 0x0;
            DDPixelFormat->dwRGBZBitMask = 0x00000000;
            break;
 
        case WINED3DFMT_D32_UNORM:
            DDPixelFormat->dwFlags = DDPF_ZBUFFER;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwZBufferBitDepth = 32;
            DDPixelFormat->dwStencilBitDepth = 0;
            DDPixelFormat->dwZBitMask = 0xFFFFFFFF;
            DDPixelFormat->dwStencilBitMask = 0x0;
            DDPixelFormat->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->dwZBufferBitDepth = 32;
            DDPixelFormat->dwStencilBitDepth = 4;
            DDPixelFormat->dwZBitMask = 0x00FFFFFF;
            DDPixelFormat->dwStencilBitMask = 0x0F000000;
            DDPixelFormat->dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_D24_UNORM_S8_UINT:
            DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwZBufferBitDepth = 32;
            DDPixelFormat->dwStencilBitDepth = 8;
            DDPixelFormat->dwZBitMask = 0x00FFFFFF;
            DDPixelFormat->dwStencilBitMask = 0xFF000000;
            DDPixelFormat->dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_X8D24_UNORM:
            DDPixelFormat->dwFlags = DDPF_ZBUFFER;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwZBufferBitDepth = 32;
            DDPixelFormat->dwStencilBitDepth = 0;
            DDPixelFormat->dwZBitMask = 0x00FFFFFF;
            DDPixelFormat->dwStencilBitMask = 0x00000000;
            DDPixelFormat->dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_S1_UINT_D15_UNORM:
            DDPixelFormat->dwFlags = DDPF_ZBUFFER | DDPF_STENCILBUFFER;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwZBufferBitDepth = 16;
            DDPixelFormat->dwStencilBitDepth = 1;
            DDPixelFormat->dwZBitMask = 0x7fff;
            DDPixelFormat->dwStencilBitMask = 0x8000;
            DDPixelFormat->dwRGBAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_UYVY:
        case WINED3DFMT_YUY2:
            DDPixelFormat->dwYUVBitCount = 16;
            DDPixelFormat->dwFlags = DDPF_FOURCC;
            DDPixelFormat->dwFourCC = wined3d_format;
            break;
 
        case WINED3DFMT_YV12:
            DDPixelFormat->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->dwLuminanceBitCount = 8;
            DDPixelFormat->dwLuminanceBitMask = 0xff;
            DDPixelFormat->dwBumpDvBitMask = 0x0;
            DDPixelFormat->dwBumpLuminanceBitMask = 0x0;
            DDPixelFormat->dwLuminanceAlphaBitMask = 0x0;
            break;
 
        case WINED3DFMT_L4A4_UNORM:
            DDPixelFormat->dwFlags = DDPF_ALPHAPIXELS | DDPF_LUMINANCE;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwLuminanceBitCount = 4;
            DDPixelFormat->dwLuminanceBitMask = 0x0f;
            DDPixelFormat->dwBumpDvBitMask = 0x0;
            DDPixelFormat->dwBumpLuminanceBitMask = 0x0;
            DDPixelFormat->dwLuminanceAlphaBitMask = 0xf0;
            break;
 
        case WINED3DFMT_L8A8_UNORM:
            DDPixelFormat->dwFlags = DDPF_ALPHAPIXELS | DDPF_LUMINANCE;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwLuminanceBitCount = 16;
            DDPixelFormat->dwLuminanceBitMask = 0x00ff;
            DDPixelFormat->dwBumpDvBitMask = 0x0;
            DDPixelFormat->dwBumpLuminanceBitMask = 0x0;
            DDPixelFormat->dwLuminanceAlphaBitMask = 0xff00;
            break;
 
        /* Bump mapping */
        case WINED3DFMT_R8G8_SNORM:
            DDPixelFormat->dwFlags = DDPF_BUMPDUDV;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwBumpBitCount = 16;
            DDPixelFormat->dwBumpDuBitMask =         0x000000ff;
            DDPixelFormat->dwBumpDvBitMask =         0x0000ff00;
            DDPixelFormat->dwBumpLuminanceBitMask =  0x00000000;
            DDPixelFormat->dwLuminanceAlphaBitMask = 0x00000000;
            break;
 
        case WINED3DFMT_R5G5_SNORM_L6_UNORM:
            DDPixelFormat->dwFlags = DDPF_BUMPDUDV | DDPF_BUMPLUMINANCE;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwBumpBitCount = 16;
            DDPixelFormat->dwBumpDuBitMask =         0x0000001f;
            DDPixelFormat->dwBumpDvBitMask =         0x000003e0;
            DDPixelFormat->dwBumpLuminanceBitMask =  0x0000fc00;
            DDPixelFormat->dwLuminanceAlphaBitMask = 0x00000000;
            break;
 
        case WINED3DFMT_R8G8_SNORM_L8X8_UNORM:
            DDPixelFormat->dwFlags = DDPF_BUMPDUDV | DDPF_BUMPLUMINANCE;
            DDPixelFormat->dwFourCC = 0;
            DDPixelFormat->dwBumpBitCount = 32;
            DDPixelFormat->dwBumpDuBitMask =         0x000000ff;
            DDPixelFormat->dwBumpDvBitMask =         0x0000ff00;
            DDPixelFormat->dwBumpLuminanceBitMask =  0x00ff0000;
            DDPixelFormat->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_device7_EnumTextureFormats(), ddraw7_EnumDisplayModes(), ddraw7_EnumSurfaces(), ddraw7_GetDisplayMode(), ddraw7_SetDisplayMode(), ddraw_surface_create(), and fixup_texture_alpha_op().

DDSD2_to_DDSD()

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

Definition at line 1242 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->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->dwZBufferBitDepth = in->ddpfPixelFormat.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->lPitch = in->lPitch;
    if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->dwBackBufferCount = in->dwBackBufferCount;
    if (in->dwFlags & DDSD_ZBUFFERBITDEPTH) out->dwZBufferBitDepth = in->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->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->dwMipMapCount = in->dwMipMapCount;
    if (in->dwFlags & DDSD_REFRESHRATE) out->dwRefreshRate = in->dwRefreshRate;
    if (in->dwFlags & DDSD_LINEARSIZE) out->dwLinearSize = in->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_surface3_GetSurfaceDesc(), ddraw_surface_lock_ddsd(), ddrawex3_GetDisplayMode(), ddrawex_surface3_GetSurfaceDesc(), ddrawex_surface3_Lock(), enum_modes_cb2(), enum_surfaces_cb2(), EnumDisplayModesCallbackThunk(), and enumsurfaces_thunk_cb().

DDSD_to_DDSD2()

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

Definition at line 1198 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->ddpfPixelFormat = in->ddpfPixelFormat;
    else if(in->dwFlags & DDSD_ZBUFFERBITDEPTH)
    {
        out->dwFlags |= DDSD_PIXELFORMAT;
        memset(&out->ddpfPixelFormat, 0, sizeof(out->ddpfPixelFormat));
        out->ddpfPixelFormat.dwSize = sizeof(out->ddpfPixelFormat);
        out->ddpfPixelFormat.dwFlags = DDPF_ZBUFFER;
        out->ddpfPixelFormat.dwZBufferBitDepth = in->dwZBufferBitDepth;
        /* 0 is not a valid DDSURFACEDESC / DDPIXELFORMAT on either side of the
         * conversion */
        out->ddpfPixelFormat.dwZBitMask = ~0U >> (32 - in->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->lPitch = in->lPitch;
    if (in->dwFlags & DDSD_BACKBUFFERCOUNT) out->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->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->dwMipMapCount = in->dwMipMapCount;
    if (in->dwFlags & DDSD_REFRESHRATE) out->dwRefreshRate = in->dwRefreshRate;
    if (in->dwFlags & DDSD_LINEARSIZE) out->dwLinearSize = in->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(), ddraw_surface3_SetSurfaceDesc(), ddrawex3_CreateSurface(), ddrawex3_EnumDisplayModes(), ddrawex3_EnumSurfaces(), ddrawex_surface3_Initialize(), and ddrawex_surface3_SetSurfaceDesc().

dump_D3DMATRIX()

void dump_D3DMATRIX

(

const D3DMATRIX *

mat

)

Definition at line 906 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 636 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_texture_init().

format_is_paletteindexed()

static BOOL format_is_paletteindexed ( const DDPIXELFORMAT *  fmt )

inlinestatic

Definition at line 643 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 915 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_device3_DrawIndexedPrimitiveVB(), 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(), and d3d_vertex_buffer_create().

hr_ddraw_from_wined3d()

HRESULT hr_ddraw_from_wined3d

(

HRESULT

hr

)

Definition at line 1183 of file utils.c.

{
    switch(hr)
    {
        case WINED3DERR_INVALIDCALL:        return DDERR_INVALIDPARAMS;
        case WINED3DERR_NOTAVAILABLE:       return DDERR_UNSUPPORTED;
        case WINEDDERR_NOTAOVERLAYSURFACE:  return DDERR_NOTAOVERLAYSURFACE;
        case WINEDDERR_OVERLAYNOTVISIBLE:   return DDERR_OVERLAYNOTVISIBLE;
        default:                            return hr;
    }
}

Referenced by d3d_device7_BeginStateBlock(), d3d_device7_CreateStateBlock(), d3d_device7_GetLight(), d3d_device7_GetLightEnable(), d3d_device7_LightEnable(), d3d_device7_SetLight(), ddraw7_EnumSurfaces(), ddraw7_SetDisplayMode(), ddraw_surface7_SetPrivateData(), ddraw_surface7_SetSurfaceDesc(), ddraw_surface7_UpdateOverlay(), ddraw_surface_create(), ddraw_surface_set_color_key(), and ddraw_texture_init().

impl_from_IDirect3DDevice()

static struct d3d_device * impl_from_IDirect3DDevice ( IDirect3DDevice *  iface )

inlinestatic

Definition at line 380 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_DeleteViewport(), d3d_device1_EndScene(), d3d_device1_EnumTextureFormats(), d3d_device1_Execute(), d3d_device1_GetCaps(), d3d_device1_GetDirect3D(), 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 385 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(), and d3d_device2_Vertex().

impl_from_IDirect3DDevice3()

static struct d3d_device * impl_from_IDirect3DDevice3 ( IDirect3DDevice3 *  iface )

inlinestatic

Definition at line 390 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 395 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_GetClipStatus(), 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 240 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 245 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 433 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 250 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 255 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 260 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(), ddraw_surface3_UpdateOverlayZOrder(), ddrawex_surface3_AddAttachedSurface(), ddrawex_surface3_AddOverlayDirtyRect(), ddrawex_surface3_AddRef(), ddrawex_surface3_Blt(), ddrawex_surface3_BltBatch(), ddrawex_surface3_BltFast(), ddrawex_surface3_DeleteAttachedSurface(), ddrawex_surface3_EnumAttachedSurfaces(), ddrawex_surface3_EnumOverlayZOrders(), ddrawex_surface3_Flip(), ddrawex_surface3_GetAttachedSurface(), ddrawex_surface3_GetBltStatus(), ddrawex_surface3_GetCaps(), ddrawex_surface3_GetClipper(), ddrawex_surface3_GetColorKey(), ddrawex_surface3_GetDC(), ddrawex_surface3_GetFlipStatus(), ddrawex_surface3_GetOverlayPosition(), ddrawex_surface3_GetPalette(), ddrawex_surface3_GetPixelFormat(), ddrawex_surface3_GetSurfaceDesc(), ddrawex_surface3_Initialize(), ddrawex_surface3_IsLost(), ddrawex_surface3_Lock(), ddrawex_surface3_PageLock(), ddrawex_surface3_PageUnlock(), ddrawex_surface3_QueryInterface(), ddrawex_surface3_Release(), ddrawex_surface3_ReleaseDC(), ddrawex_surface3_Restore(), ddrawex_surface3_SetClipper(), ddrawex_surface3_SetColorKey(), ddrawex_surface3_SetOverlayPosition(), ddrawex_surface3_SetPalette(), ddrawex_surface3_SetSurfaceDesc(), ddrawex_surface3_Unlock(), ddrawex_surface3_UpdateOverlay(), ddrawex_surface3_UpdateOverlayDisplay(), ddrawex_surface3_UpdateOverlayZOrder(), and unsafe_impl_from_IDirectDrawSurface3().

impl_from_IDirectDrawSurface4()

static struct ddraw_surface * impl_from_IDirectDrawSurface4 ( IDirectDrawSurface4 *  iface )

inlinestatic

Definition at line 265 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(), ddraw_surface4_UpdateOverlayZOrder(), ddrawex_surface4_AddAttachedSurface(), ddrawex_surface4_AddOverlayDirtyRect(), ddrawex_surface4_AddRef(), ddrawex_surface4_Blt(), ddrawex_surface4_BltBatch(), ddrawex_surface4_BltFast(), ddrawex_surface4_ChangeUniquenessValue(), ddrawex_surface4_DeleteAttachedSurface(), ddrawex_surface4_EnumAttachedSurfaces(), ddrawex_surface4_EnumOverlayZOrders(), ddrawex_surface4_Flip(), ddrawex_surface4_FreePrivateData(), ddrawex_surface4_GetAttachedSurface(), ddrawex_surface4_GetBltStatus(), ddrawex_surface4_GetCaps(), ddrawex_surface4_GetClipper(), ddrawex_surface4_GetColorKey(), ddrawex_surface4_GetDC(), ddrawex_surface4_GetFlipStatus(), ddrawex_surface4_GetOverlayPosition(), ddrawex_surface4_GetPalette(), ddrawex_surface4_GetPixelFormat(), ddrawex_surface4_GetPrivateData(), ddrawex_surface4_GetSurfaceDesc(), ddrawex_surface4_GetUniquenessValue(), ddrawex_surface4_Initialize(), ddrawex_surface4_IsLost(), ddrawex_surface4_Lock(), ddrawex_surface4_PageLock(), ddrawex_surface4_PageUnlock(), ddrawex_surface4_QueryInterface(), ddrawex_surface4_Release(), ddrawex_surface4_ReleaseDC(), ddrawex_surface4_Restore(), ddrawex_surface4_SetClipper(), ddrawex_surface4_SetColorKey(), ddrawex_surface4_SetOverlayPosition(), ddrawex_surface4_SetPalette(), ddrawex_surface4_SetPrivateData(), ddrawex_surface4_SetSurfaceDesc(), ddrawex_surface4_Unlock(), ddrawex_surface4_UpdateOverlay(), ddrawex_surface4_UpdateOverlayDisplay(), ddrawex_surface4_UpdateOverlayZOrder(), and unsafe_impl_from_IDirectDrawSurface4().

impl_from_IDirectDrawSurface7()

static struct ddraw_surface * impl_from_IDirectDrawSurface7 ( IDirectDrawSurface7 *  iface )

inlinestatic

Definition at line 270 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_EnumSurfaces(), 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 48 of file light.c.

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

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

light_deactivate()

void light_deactivate

(

struct d3d_light *

light

)

Definition at line 74 of file light.c.

{
    struct d3d_device *device;
 
    TRACE("light %p.\n", light);
 
    if (!light->active_viewport || !light->active_viewport->active_device
            || light->active_viewport->active_device->current_viewport != light->active_viewport)
    {
        assert(!light->active_light_index);
        return;
    }
 
    device = light->active_viewport->active_device;
    if (light->active_light_index)
    {
        IDirect3DDevice7_LightEnable(&device->IDirect3DDevice7_iface, light->active_light_index, FALSE);
        viewport_free_active_light_index(light);
    }
}

Referenced by d3d_light_SetLight(), d3d_viewport_DeleteLight(), viewport_alloc_active_light_index(), and viewport_deactivate().

material_activate()

void material_activate

(

struct d3d_material *

material

)

Definition at line 444 of file material.c.

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

Referenced by d3d_device3_SetLightState().

multiply_matrix()

void multiply_matrix	(	struct wined3d_matrix *	dst,
		const struct wined3d_matrix *	src1,
		const struct wined3d_matrix *	src2
	)

Definition at line 1153 of file utils.c.

{
    struct wined3d_matrix 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);
 
    *dst = temp;
}

Referenced by d3d_device3_MultiplyTransform(), d3d_device3_SetTransform(), d3d_viewport_TransformVertices(), get_projection_matrix(), init_transformed_lights(), prepare_clip_space_planes(), process_vertices_strided(), update_clip_space(), and wined3d_stateblock_multiply_transform().

unsafe_impl_from_IDirect3DDevice()

struct d3d_device * unsafe_impl_from_IDirect3DDevice

(

IDirect3DDevice *

iface

)

Definition at line 6810 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 6803 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().

unsafe_impl_from_IDirect3DDevice3()

struct d3d_device * unsafe_impl_from_IDirect3DDevice3

(

IDirect3DDevice3 *

iface

)

Definition at line 6796 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 6789 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 790 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 257 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 6037 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 6030 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 510 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 1224 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(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 1216 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(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 1209 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 389 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 232 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 6014 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 5966 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(), and ddrawex4_DuplicateSurface().

unsafe_impl_from_IDirectDrawSurface7()

struct ddraw_surface * unsafe_impl_from_IDirectDrawSurface7

(

IDirectDrawSurface7 *

iface

)

Definition at line 5950 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(), 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 51 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);
        }
    }
 
    if (This->version == DDRAW_VIEWPORT_VERSION_NONE)
    {
        TRACE("Viewport data was not set.\n");
        return;
    }
 
    /* And copy the values in the structure used by the device */
    if (This->version == DDRAW_VIEWPORT_VERSION_2)
    {
        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().

viewport_alloc_active_light_index()

void viewport_alloc_active_light_index

(

struct d3d_light *

light

)

Definition at line 121 of file viewport.c.

{
    struct d3d_viewport *vp = light->active_viewport;
    unsigned int i, map;
 
    TRACE("vp %p, light %p, index %lu, active_lights_count %lu.\n",
            vp, light, light->active_light_index, vp->active_lights_count);
 
    if (light->active_light_index)
        return;
 
    if (vp->active_lights_count >= DDRAW_MAX_ACTIVE_LIGHTS)
    {
        struct d3d_light *l;
 
        LIST_FOR_EACH_ENTRY(l, &vp->light_list, struct d3d_light, entry)
        {
            if (l->active_light_index)
            {
                WARN("Too many active lights, viewport %p, light %p, deactivating %p.\n", vp, light, l);
                light_deactivate(l);
 
                /* Recycle active lights in a FIFO way. */
                list_remove(&light->entry);
                list_add_tail(&vp->light_list, &light->entry);
                break;
            }
        }
    }
 
    map = ~vp->map_lights;
    assert(vp->active_lights_count < DDRAW_MAX_ACTIVE_LIGHTS && map);
    i = wined3d_bit_scan(&map);
    light->active_light_index = i + 1;
    ++vp->active_lights_count;
    vp->map_lights |= 1u << i;
}

Referenced by light_activate().

viewport_deactivate()

void viewport_deactivate

(

struct d3d_viewport *

viewport

)

Definition at line 111 of file viewport.c.

{
    struct d3d_light *light;
 
    LIST_FOR_EACH_ENTRY(light, &viewport->light_list, struct d3d_light, entry)
    {
        light_deactivate(light);
    }
}

Referenced by d3d_device3_DeleteViewport(), and d3d_device3_SetCurrentViewport().

viewport_free_active_light_index()

void viewport_free_active_light_index

(

struct d3d_light *

light

)

Definition at line 159 of file viewport.c.

{
    struct d3d_viewport *vp = light->active_viewport;
 
    TRACE("vp %p, light %p, index %lu, active_lights_count %lu, map_lights %#lx.\n",
            vp, light, light->active_light_index, vp->active_lights_count, vp->map_lights);
 
    if (!light->active_light_index)
        return;
 
    assert(vp->map_lights & (1u << (light->active_light_index - 1)));
 
    --vp->active_lights_count;
    vp->map_lights &= ~(1u << (light->active_light_index - 1));
    light->active_light_index = 0;
}

Referenced by light_deactivate().

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 593 of file utils.c.

{
    if (pf->dwFlags & DDPF_ALPHA)
    {
        DWORD size, mask;
 
        size = pf->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->dwRBitMask);
        wined3d_colour->g = colour_to_float(colour, pf->dwGBitMask);
        wined3d_colour->b = colour_to_float(colour, pf->dwBBitMask);
        if (pf->dwFlags & DDPF_ALPHAPIXELS)
            wined3d_colour->a = colour_to_float(colour, pf->dwRGBAlphaBitMask);
        else
            wined3d_colour->a = 0.0f;
        return TRUE;
    }
 
    if (pf->dwFlags & DDPF_ZBUFFER)
    {
        wined3d_colour->r = colour_to_float(colour, pf->dwZBitMask);
        if (pf->dwFlags & DDPF_STENCILBUFFER)
            wined3d_colour->g = colour_to_float(colour, pf->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 330 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->dwRGBBitCount)
        {
            case 8:
                /* This is the only format that can match here */
                return WINED3DFMT_B2G3R3_UNORM;
 
            case 16:
                /* Read the Color masks */
                if( (DDPixelFormat->dwRBitMask == 0xF800) &&
                    (DDPixelFormat->dwGBitMask == 0x07E0) &&
                    (DDPixelFormat->dwBBitMask == 0x001F) )
                {
                    return WINED3DFMT_B5G6R5_UNORM;
                }
 
                if( (DDPixelFormat->dwRBitMask == 0x7C00) &&
                    (DDPixelFormat->dwGBitMask == 0x03E0) &&
                    (DDPixelFormat->dwBBitMask == 0x001F) )
                {
                    if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
                        (DDPixelFormat->dwRGBAlphaBitMask == 0x8000))
                        return WINED3DFMT_B5G5R5A1_UNORM;
                    else
                        return WINED3DFMT_B5G5R5X1_UNORM;
                }
 
                if( (DDPixelFormat->dwRBitMask == 0x0F00) &&
                    (DDPixelFormat->dwGBitMask == 0x00F0) &&
                    (DDPixelFormat->dwBBitMask == 0x000F) )
                {
                    if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
                        (DDPixelFormat->dwRGBAlphaBitMask == 0xF000))
                        return WINED3DFMT_B4G4R4A4_UNORM;
                    else
                        return WINED3DFMT_B4G4R4X4_UNORM;
                }
 
                if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
                    (DDPixelFormat->dwRGBAlphaBitMask == 0xFF00) &&
                    (DDPixelFormat->dwRBitMask == 0x00E0) &&
                    (DDPixelFormat->dwGBitMask == 0x001C) &&
                    (DDPixelFormat->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->dwRBitMask == 0x00FF0000) &&
                    (DDPixelFormat->dwGBitMask == 0x0000FF00) &&
                    (DDPixelFormat->dwBBitMask == 0x000000FF) )
                {
                    if( (DDPixelFormat->dwFlags & DDPF_ALPHAPIXELS) &&
                        (DDPixelFormat->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->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->dwLuminanceBitCount)
            {
                case 4:
                    if(DDPixelFormat->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->dwAlphaBitDepth == 8)
                        return WINED3DFMT_L8A8_UNORM;
                    WARN("Unknown Alpha / Lumincase bit depth combination.\n");
                    return WINED3DFMT_UNKNOWN;
            }
        }
        else
        {
            /* Luminance-only */
            switch(DDPixelFormat->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 %lu.\n", DDPixelFormat->dwLuminanceBitCount);
                    return WINED3DFMT_UNKNOWN;
             }
        }
    }
    else if(DDPixelFormat->dwFlags & DDPF_ZBUFFER)
    {
        /* Z buffer */
        if(DDPixelFormat->dwFlags & DDPF_STENCILBUFFER)
        {
            switch(DDPixelFormat->dwZBufferBitDepth)
            {
                case 16:
                    if (DDPixelFormat->dwStencilBitDepth == 1) return WINED3DFMT_S1_UINT_D15_UNORM;
                    WARN("Unknown depth stencil format: 16 z bits, %lu stencil bits.\n",
                            DDPixelFormat->dwStencilBitDepth);
                    return WINED3DFMT_UNKNOWN;
 
                case 32:
                    if (DDPixelFormat->dwStencilBitDepth == 8) return WINED3DFMT_D24_UNORM_S8_UINT;
                    else if (DDPixelFormat->dwStencilBitDepth == 4) return WINED3DFMT_S4X4_UINT_D24_UNORM;
                    WARN("Unknown depth stencil format: 32 z bits, %lu stencil bits.\n",
                            DDPixelFormat->dwStencilBitDepth);
                    return WINED3DFMT_UNKNOWN;
 
                default:
                    WARN("Unknown depth stencil format: %lu z bits, %lu stencil bits.\n",
                            DDPixelFormat->dwZBufferBitDepth, DDPixelFormat->dwStencilBitDepth);
                    return WINED3DFMT_UNKNOWN;
            }
        }
        else
        {
            switch(DDPixelFormat->dwZBufferBitDepth)
            {
                case 16:
                    return WINED3DFMT_D16_UNORM;
 
                case 24:
                    return WINED3DFMT_X8D24_UNORM;
 
                case 32:
                    if (DDPixelFormat->dwZBitMask == 0x00FFFFFF) return WINED3DFMT_X8D24_UNORM;
                    else if (DDPixelFormat->dwZBitMask == 0xFFFFFF00) return WINED3DFMT_X8D24_UNORM;
                    else if (DDPixelFormat->dwZBitMask == 0xFFFFFFFF) return WINED3DFMT_D32_UNORM;
                    WARN("Unknown depth-only format: 32 z bits, mask 0x%08lx\n",
                            DDPixelFormat->dwZBitMask);
                    return WINED3DFMT_UNKNOWN;
 
                default:
                    WARN("Unknown depth-only format: %lu z bits, mask 0x%08lx\n",
                            DDPixelFormat->dwZBufferBitDepth, DDPixelFormat->dwZBitMask);
                    return WINED3DFMT_UNKNOWN;
            }
        }
    }
    else if(DDPixelFormat->dwFlags & DDPF_FOURCC)
    {
        return DDPixelFormat->dwFourCC;
    }
    else if(DDPixelFormat->dwFlags & DDPF_BUMPDUDV)
    {
        if( (DDPixelFormat->dwBumpBitCount         == 16        ) &&
            (DDPixelFormat->dwBumpDuBitMask        == 0x000000ff) &&
            (DDPixelFormat->dwBumpDvBitMask        == 0x0000ff00) &&
            (DDPixelFormat->dwBumpLuminanceBitMask == 0x00000000) )
        {
            return WINED3DFMT_R8G8_SNORM;
        }
        else if ( (DDPixelFormat->dwBumpBitCount         == 16        ) &&
                  (DDPixelFormat->dwBumpDuBitMask        == 0x0000001f) &&
                  (DDPixelFormat->dwBumpDvBitMask        == 0x000003e0) &&
                  (DDPixelFormat->dwBumpLuminanceBitMask == 0x0000fc00) )
        {
            return WINED3DFMT_R5G5_SNORM_L6_UNORM;
        }
        else if ( (DDPixelFormat->dwBumpBitCount         == 32        ) &&
                  (DDPixelFormat->dwBumpDuBitMask        == 0x000000ff) &&
                  (DDPixelFormat->dwBumpDvBitMask        == 0x0000ff00) &&
                  (DDPixelFormat->dwBumpLuminanceBitMask == 0x00ff0000) )
        {
            return WINED3DFMT_R8G8_SNORM_L8X8_UNORM;
        }
    }
 
    WARN("Unknown Pixelformat.\n");
    return WINED3DFMT_UNKNOWN;
}

Referenced by ddraw_surface7_SetSurfaceDesc(), ddraw_surface_create(), and wined3d_resource_desc_from_ddraw().

wined3dmapflags_from_ddrawmapflags()

unsigned int wined3dmapflags_from_ddrawmapflags

(

unsigned int

flags

)

Definition at line 561 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

ddraw_null_wined3d_parent_ops

const struct wined3d_parent_ops ddraw_null_wined3d_parent_ops

extern

Definition at line 82 of file ddraw.c.

Referenced by d3d_execute_buffer_SetExecuteData(), d3d_vertex_buffer_create_wined3d_buffer(), ddraw_attach_d3d_device(), ddraw_find_decl(), ddraw_surface7_SetSurfaceDesc(), ddraw_texture_init(), ddraw_texture_rename_to(), and device_parent_texture_sub_resource_created().

force_refresh_rate

DWORD force_refresh_rate

extern

Definition at line 38 of file main.c.

Referenced by ddraw7_SetDisplayMode(), and DllMain().

global_handle_table

struct ddraw_handle_table global_handle_table

extern

Definition at line 40 of file main.c.

Referenced by d3d_device2_SwapTextureHandles(), ddraw_allocate_handle(), ddraw_free_handle(), ddraw_get_object(), and DllMain().

IID_D3DDEVICE_WineD3D

const GUID IID_D3DDEVICE_WineD3D

extern

Definition at line 36 of file device.c.

Referenced by d3d1_FindDevice(), d3d2_FindDevice(), d3d3_FindDevice(), d3d7_EnumZBufferFormats(), ddraw_find_device(), and ddraw_surface7_QueryInterface().