d3dx9_private.h File Reference

#include <stdint.h>
#include "wine/debug.h"
#include "wine/rbtree.h"
#include "d3dx9.h"

Include dependency graph for d3dx9_private.h:

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

Go to the source code of this file.

Classes
struct	vec4
struct	d3dx_color
struct	volume
struct	pixel_format_desc
struct	d3dx_pixels
struct	d3dx_image
struct	d3dx_include_from_file
struct	d3dx_const_param_eval_output
struct	d3dx_const_tab
struct	d3dx_regstore
struct	d3dx_preshader
struct	d3dx_param_eval
struct	param_rb_entry
struct	d3dx_parameter
struct	d3dx_top_level_parameter
struct	d3dx_shared_data
struct	d3dx_parameters_store
struct	ctab_constant

Macros
#define	COBJMACROS
#define	ULONG64_MAX   (~(ULONG64)0)
#define	FOURCC_TX_1   0x54580100
#define	D3DX9_FILTER_INVALID_BITS   0xff80fff8
#define	D3DX_IMAGE_INFO_ONLY   1
#define	SET_D3D_STATE_(manager, device, method, ...)
#define	SET_D3D_STATE(base_effect, ...)   SET_D3D_STATE_(base_effect->manager, base_effect->device, __VA_ARGS__)

Enumerations
enum	range { RANGE_FULL = 0 , RANGE_UNORM = 1 , RANGE_SNORM = 2 }
enum	d3dx_pixel_format_id {   D3DX_PIXEL_FORMAT_B8G8R8_UNORM , D3DX_PIXEL_FORMAT_B8G8R8A8_UNORM , D3DX_PIXEL_FORMAT_B8G8R8X8_UNORM , D3DX_PIXEL_FORMAT_R8G8B8A8_UNORM ,   D3DX_PIXEL_FORMAT_R8G8B8X8_UNORM , D3DX_PIXEL_FORMAT_B5G6R5_UNORM , D3DX_PIXEL_FORMAT_B5G5R5X1_UNORM , D3DX_PIXEL_FORMAT_B5G5R5A1_UNORM ,   D3DX_PIXEL_FORMAT_B2G3R3_UNORM , D3DX_PIXEL_FORMAT_B2G3R3A8_UNORM , D3DX_PIXEL_FORMAT_B4G4R4A4_UNORM , D3DX_PIXEL_FORMAT_B4G4R4X4_UNORM ,   D3DX_PIXEL_FORMAT_B10G10R10A2_UNORM , D3DX_PIXEL_FORMAT_R10G10B10A2_UNORM , D3DX_PIXEL_FORMAT_R16G16B16_UNORM , D3DX_PIXEL_FORMAT_R16G16B16A16_UNORM ,   D3DX_PIXEL_FORMAT_R16G16_UNORM , D3DX_PIXEL_FORMAT_A8_UNORM , D3DX_PIXEL_FORMAT_L8A8_UNORM , D3DX_PIXEL_FORMAT_L4A4_UNORM ,   D3DX_PIXEL_FORMAT_L8_UNORM , D3DX_PIXEL_FORMAT_L16_UNORM , D3DX_PIXEL_FORMAT_DXT1_UNORM , D3DX_PIXEL_FORMAT_DXT2_UNORM ,   D3DX_PIXEL_FORMAT_DXT3_UNORM , D3DX_PIXEL_FORMAT_DXT4_UNORM , D3DX_PIXEL_FORMAT_DXT5_UNORM , D3DX_PIXEL_FORMAT_R16_FLOAT ,   D3DX_PIXEL_FORMAT_R16G16_FLOAT , D3DX_PIXEL_FORMAT_R16G16B16A16_FLOAT , D3DX_PIXEL_FORMAT_R32_FLOAT , D3DX_PIXEL_FORMAT_R32G32_FLOAT ,   D3DX_PIXEL_FORMAT_R32G32B32A32_FLOAT , D3DX_PIXEL_FORMAT_P8_UINT , D3DX_PIXEL_FORMAT_P8_UINT_A8_UNORM , D3DX_PIXEL_FORMAT_U8V8W8Q8_SNORM ,   D3DX_PIXEL_FORMAT_U16V16W16Q16_SNORM , D3DX_PIXEL_FORMAT_U8V8_SNORM , D3DX_PIXEL_FORMAT_U16V16_SNORM , D3DX_PIXEL_FORMAT_U8V8_SNORM_L8X8_UNORM ,   D3DX_PIXEL_FORMAT_U10V10W10_SNORM_A2_UNORM , D3DX_PIXEL_FORMAT_R8G8_B8G8_UNORM , D3DX_PIXEL_FORMAT_G8R8_G8B8_UNORM , D3DX_PIXEL_FORMAT_UYVY ,   D3DX_PIXEL_FORMAT_YUY2 , D3DX_PIXEL_FORMAT_COUNT }
enum	component_type {   CTYPE_EMPTY , CTYPE_UNORM , CTYPE_SNORM , CTYPE_FLOAT ,   CTYPE_LUMA , CTYPE_INDEX }
enum	format_flag { FMT_FLAG_DXT = 0x01 , FMT_FLAG_PACKED = 0x02 , FMT_FLAG_INTERNAL = 0x04 }
enum	pres_reg_tables {   PRES_REGTAB_IMMED , PRES_REGTAB_CONST , PRES_REGTAB_INPUT , PRES_REGTAB_OCONST ,   PRES_REGTAB_OBCONST , PRES_REGTAB_OICONST , PRES_REGTAB_TEMP , PRES_REGTAB_COUNT ,   PRES_REGTAB_FIRST_SHADER = PRES_REGTAB_CONST }

Functions
static HRESULT	d3dx9_validate_filter (uint32_t filter)
static HRESULT	d3dx9_handle_load_filter (DWORD *filter)
static void	set_d3dx_color (struct d3dx_color *color, const struct vec4 *value, enum range rgb_range, enum range a_range)
static void	set_volume_struct (struct volume *volume, uint32_t width, uint32_t height, uint32_t depth)
static void	set_d3dx_pixels (struct d3dx_pixels *pixels, const void *data, uint32_t row_pitch, uint32_t slice_pitch, const PALETTEENTRY *palette, uint32_t width, uint32_t height, uint32_t depth, const RECT *unaligned_rect)
HRESULT	d3dx_image_init (const void *src_data, uint32_t src_data_size, struct d3dx_image *image, uint32_t starting_mip_level, uint32_t flags)
void	d3dx_image_cleanup (struct d3dx_image *image)
HRESULT	d3dx_image_get_pixels (struct d3dx_image *image, uint32_t layer, uint32_t mip_level, struct d3dx_pixels *pixels)
void	d3dximage_info_from_d3dx_image (D3DXIMAGE_INFO *info, struct d3dx_image *image)
static BOOL	is_unknown_format (const struct pixel_format_desc *format)
static BOOL	is_index_format (const struct pixel_format_desc *format)
static BOOL	is_compressed_format (const struct pixel_format_desc *format)
static BOOL	is_packed_format (const struct pixel_format_desc *format)
static BOOL	format_types_match (const struct pixel_format_desc *src, const struct pixel_format_desc *dst)
static BOOL	is_internal_format (const struct pixel_format_desc *format)
static BOOL	is_conversion_from_supported (const struct pixel_format_desc *format)
static BOOL	is_conversion_to_supported (const struct pixel_format_desc *format)
HRESULT	map_view_of_file (const WCHAR *filename, void **buffer, DWORD *length)
HRESULT	load_resource_into_memory (HMODULE module, HRSRC resinfo, void **buffer, DWORD *length)
HRESULT	write_buffer_to_file (const WCHAR *filename, ID3DXBuffer *buffer)
D3DFORMAT	d3dformat_from_d3dx_pixel_format_id (enum d3dx_pixel_format_id format)
enum d3dx_pixel_format_id	d3dx_pixel_format_id_from_d3dformat (D3DFORMAT format)
const struct pixel_format_desc *	get_d3dx_pixel_format_info (enum d3dx_pixel_format_id format)
const struct pixel_format_desc *	get_format_info (D3DFORMAT format)
const struct pixel_format_desc *	get_format_info_idx (int idx)
void	format_to_d3dx_color (const struct pixel_format_desc *format, const BYTE *src, const PALETTEENTRY *palette, struct d3dx_color *dst)
void	format_from_d3dx_color (const struct pixel_format_desc *format, const struct d3dx_color *src, BYTE *dst)
void	copy_pixels (const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *size, const struct pixel_format_desc *format)
void	convert_argb_pixels (const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, const struct volume *src_size, const struct pixel_format_desc *src_format, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *dst_size, const struct pixel_format_desc *dst_format, D3DCOLOR color_key, const PALETTEENTRY *palette)
void	point_filter_argb_pixels (const BYTE *src, UINT src_row_pitch, UINT src_slice_pitch, const struct volume *src_size, const struct pixel_format_desc *src_format, BYTE *dst, UINT dst_row_pitch, UINT dst_slice_pitch, const struct volume *dst_size, const struct pixel_format_desc *dst_format, D3DCOLOR color_key, const PALETTEENTRY *palette)
HRESULT	lock_surface (IDirect3DSurface9 *surface, const RECT *surface_rect, D3DLOCKED_RECT *lock, IDirect3DSurface9 **temp_surface, BOOL write)
HRESULT	unlock_surface (IDirect3DSurface9 *surface, const RECT *surface_rect, IDirect3DSurface9 *temp_surface, BOOL update)
HRESULT	d3dx_pixels_init (const void *data, uint32_t row_pitch, uint32_t slice_pitch, const PALETTEENTRY *palette, enum d3dx_pixel_format_id format, uint32_t left, uint32_t top, uint32_t right, uint32_t bottom, uint32_t front, uint32_t back, struct d3dx_pixels *pixels)
HRESULT	d3dx_load_pixels_from_pixels (struct d3dx_pixels *dst_pixels, const struct pixel_format_desc *dst_desc, struct d3dx_pixels *src_pixels, const struct pixel_format_desc *src_desc, uint32_t filter_flags, uint32_t color_key)
void	get_aligned_rect (uint32_t left, uint32_t top, uint32_t right, uint32_t bottom, uint32_t width, uint32_t height, const struct pixel_format_desc *fmt_desc, RECT *aligned_rect)
unsigned short	float_32_to_16 (const float in)
float	float_16_to_32 (const unsigned short in)
const char *	debug_d3dxparameter_class (D3DXPARAMETER_CLASS c)
const char *	debug_d3dxparameter_type (D3DXPARAMETER_TYPE t)
const char *	debug_d3dxparameter_registerset (D3DXREGISTER_SET r)
static BOOL	get_bool (D3DXPARAMETER_TYPE type, const void *data)
static int	get_int (D3DXPARAMETER_TYPE type, const void *data)
static float	get_float (D3DXPARAMETER_TYPE type, const void *data)
static void	set_number (void *outdata, D3DXPARAMETER_TYPE outtype, const void *indata, D3DXPARAMETER_TYPE intype)
static BOOL	is_param_type_sampler (D3DXPARAMETER_TYPE type)
static uint32_t	make_pow2 (uint32_t num)
static BOOL	is_top_level_parameter (struct d3dx_parameter *param)
static struct d3dx_top_level_parameter *	top_level_parameter_from_parameter (struct d3dx_parameter *param)
static ULONG64	next_update_version (ULONG64 *version_counter)
static BOOL	is_top_level_param_dirty (struct d3dx_top_level_parameter *param, ULONG64 update_version)
static BOOL	is_param_dirty (struct d3dx_parameter *param, ULONG64 update_version)
HRESULT	d3dx_init_parameters_store (struct d3dx_parameters_store *store, unsigned int count)
void	d3dx_parameters_store_cleanup (struct d3dx_parameters_store *store)
struct d3dx_parameter *	get_parameter_by_name (struct d3dx_parameters_store *store, struct d3dx_parameter *parameter, const char *name)
HRESULT	d3dx_create_param_eval (struct d3dx_parameters_store *parameters, void *byte_code, unsigned int byte_code_size, D3DXPARAMETER_TYPE type, struct d3dx_param_eval **peval, ULONG64 *version_counter, const char **skip_constants, unsigned int skip_constants_count)
void	d3dx_free_param_eval (struct d3dx_param_eval *peval)
HRESULT	d3dx_evaluate_parameter (struct d3dx_param_eval *peval, const struct d3dx_parameter *param, void *param_value)
HRESULT	d3dx_param_eval_set_shader_constants (ID3DXEffectStateManager *manager, struct IDirect3DDevice9 *device, struct d3dx_param_eval *peval, BOOL update_all)
BOOL	is_param_eval_input_dirty (struct d3dx_param_eval *peval, ULONG64 update_version)
const struct ctab_constant *	d3dx_shader_get_ctab_constant (ID3DXConstantTable *iface, D3DXHANDLE constant)

Variables
CRITICAL_SECTION	from_file_mutex
const struct ID3DXIncludeVtbl	d3dx_include_from_file_vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 29 of file d3dx9_private.h.

D3DX9_FILTER_INVALID_BITS

#define D3DX9_FILTER_INVALID_BITS   0xff80fff8

Definition at line 36 of file d3dx9_private.h.

D3DX_IMAGE_INFO_ONLY

#define D3DX_IMAGE_INFO_ONLY   1

Definition at line 199 of file d3dx9_private.h.

FOURCC_TX_1

#define FOURCC_TX_1   0x54580100

Definition at line 34 of file d3dx9_private.h.

SET_D3D_STATE

#define SET_D3D_STATE	(		base_effect,
			...
	)		SET_D3D_STATE_(base_effect->manager, base_effect->device, __VA_ARGS__)

Definition at line 609 of file d3dx9_private.h.

SET_D3D_STATE_

#define SET_D3D_STATE_	(		manager,
			device,
			method,
			...
	)

Value:

        (manager ? manager->lpVtbl->method(manager, __VA_ARGS__) \
        : device->lpVtbl->method(device, __VA_ARGS__))

Definition at line 601 of file d3dx9_private.h.

ULONG64_MAX

#define ULONG64_MAX   (~(ULONG64)0)

Definition at line 32 of file d3dx9_private.h.

Enumeration Type Documentation

component_type

enum component_type

Enumerator
CTYPE_EMPTY
CTYPE_UNORM
CTYPE_SNORM
CTYPE_FLOAT
CTYPE_LUMA
CTYPE_INDEX

Definition at line 145 of file d3dx9_private.h.

{
    CTYPE_EMPTY,
    CTYPE_UNORM,
    CTYPE_SNORM,
    CTYPE_FLOAT,
    CTYPE_LUMA,
    CTYPE_INDEX,
};

d3dx_pixel_format_id

enum d3dx_pixel_format_id

Enumerator
D3DX_PIXEL_FORMAT_B8G8R8_UNORM
D3DX_PIXEL_FORMAT_B8G8R8A8_UNORM
D3DX_PIXEL_FORMAT_B8G8R8X8_UNORM
D3DX_PIXEL_FORMAT_R8G8B8A8_UNORM
D3DX_PIXEL_FORMAT_R8G8B8X8_UNORM
D3DX_PIXEL_FORMAT_B5G6R5_UNORM
D3DX_PIXEL_FORMAT_B5G5R5X1_UNORM
D3DX_PIXEL_FORMAT_B5G5R5A1_UNORM
D3DX_PIXEL_FORMAT_B2G3R3_UNORM
D3DX_PIXEL_FORMAT_B2G3R3A8_UNORM
D3DX_PIXEL_FORMAT_B4G4R4A4_UNORM
D3DX_PIXEL_FORMAT_B4G4R4X4_UNORM
D3DX_PIXEL_FORMAT_B10G10R10A2_UNORM
D3DX_PIXEL_FORMAT_R10G10B10A2_UNORM
D3DX_PIXEL_FORMAT_R16G16B16_UNORM
D3DX_PIXEL_FORMAT_R16G16B16A16_UNORM
D3DX_PIXEL_FORMAT_R16G16_UNORM
D3DX_PIXEL_FORMAT_A8_UNORM
D3DX_PIXEL_FORMAT_L8A8_UNORM
D3DX_PIXEL_FORMAT_L4A4_UNORM
D3DX_PIXEL_FORMAT_L8_UNORM
D3DX_PIXEL_FORMAT_L16_UNORM
D3DX_PIXEL_FORMAT_DXT1_UNORM
D3DX_PIXEL_FORMAT_DXT2_UNORM
D3DX_PIXEL_FORMAT_DXT3_UNORM
D3DX_PIXEL_FORMAT_DXT4_UNORM
D3DX_PIXEL_FORMAT_DXT5_UNORM
D3DX_PIXEL_FORMAT_R16_FLOAT
D3DX_PIXEL_FORMAT_R16G16_FLOAT
D3DX_PIXEL_FORMAT_R16G16B16A16_FLOAT
D3DX_PIXEL_FORMAT_R32_FLOAT
D3DX_PIXEL_FORMAT_R32G32_FLOAT
D3DX_PIXEL_FORMAT_R32G32B32A32_FLOAT
D3DX_PIXEL_FORMAT_P8_UINT
D3DX_PIXEL_FORMAT_P8_UINT_A8_UNORM
D3DX_PIXEL_FORMAT_U8V8W8Q8_SNORM
D3DX_PIXEL_FORMAT_U16V16W16Q16_SNORM
D3DX_PIXEL_FORMAT_U8V8_SNORM
D3DX_PIXEL_FORMAT_U16V16_SNORM
D3DX_PIXEL_FORMAT_U8V8_SNORM_L8X8_UNORM
D3DX_PIXEL_FORMAT_U10V10W10_SNORM_A2_UNORM
D3DX_PIXEL_FORMAT_R8G8_B8G8_UNORM
D3DX_PIXEL_FORMAT_G8R8_G8B8_UNORM
D3DX_PIXEL_FORMAT_UYVY
D3DX_PIXEL_FORMAT_YUY2
D3DX_PIXEL_FORMAT_COUNT

Definition at line 94 of file d3dx9_private.h.

{
    D3DX_PIXEL_FORMAT_B8G8R8_UNORM,
    D3DX_PIXEL_FORMAT_B8G8R8A8_UNORM,
    D3DX_PIXEL_FORMAT_B8G8R8X8_UNORM,
    D3DX_PIXEL_FORMAT_R8G8B8A8_UNORM,
    D3DX_PIXEL_FORMAT_R8G8B8X8_UNORM,
    D3DX_PIXEL_FORMAT_B5G6R5_UNORM,
    D3DX_PIXEL_FORMAT_B5G5R5X1_UNORM,
    D3DX_PIXEL_FORMAT_B5G5R5A1_UNORM,
    D3DX_PIXEL_FORMAT_B2G3R3_UNORM,
    D3DX_PIXEL_FORMAT_B2G3R3A8_UNORM,
    D3DX_PIXEL_FORMAT_B4G4R4A4_UNORM,
    D3DX_PIXEL_FORMAT_B4G4R4X4_UNORM,
    D3DX_PIXEL_FORMAT_B10G10R10A2_UNORM,
    D3DX_PIXEL_FORMAT_R10G10B10A2_UNORM,
    D3DX_PIXEL_FORMAT_R16G16B16_UNORM,
    D3DX_PIXEL_FORMAT_R16G16B16A16_UNORM,
    D3DX_PIXEL_FORMAT_R16G16_UNORM,
    D3DX_PIXEL_FORMAT_A8_UNORM,
    D3DX_PIXEL_FORMAT_L8A8_UNORM,
    D3DX_PIXEL_FORMAT_L4A4_UNORM,
    D3DX_PIXEL_FORMAT_L8_UNORM,
    D3DX_PIXEL_FORMAT_L16_UNORM,
    D3DX_PIXEL_FORMAT_DXT1_UNORM,
    D3DX_PIXEL_FORMAT_DXT2_UNORM,
    D3DX_PIXEL_FORMAT_DXT3_UNORM,
    D3DX_PIXEL_FORMAT_DXT4_UNORM,
    D3DX_PIXEL_FORMAT_DXT5_UNORM,
    D3DX_PIXEL_FORMAT_R16_FLOAT,
    D3DX_PIXEL_FORMAT_R16G16_FLOAT,
    D3DX_PIXEL_FORMAT_R16G16B16A16_FLOAT,
    D3DX_PIXEL_FORMAT_R32_FLOAT,
    D3DX_PIXEL_FORMAT_R32G32_FLOAT,
    D3DX_PIXEL_FORMAT_R32G32B32A32_FLOAT,
    D3DX_PIXEL_FORMAT_P8_UINT,
    D3DX_PIXEL_FORMAT_P8_UINT_A8_UNORM,
    D3DX_PIXEL_FORMAT_U8V8W8Q8_SNORM,
    D3DX_PIXEL_FORMAT_U16V16W16Q16_SNORM,
    D3DX_PIXEL_FORMAT_U8V8_SNORM,
    D3DX_PIXEL_FORMAT_U16V16_SNORM,
    D3DX_PIXEL_FORMAT_U8V8_SNORM_L8X8_UNORM,
    D3DX_PIXEL_FORMAT_U10V10W10_SNORM_A2_UNORM,
    D3DX_PIXEL_FORMAT_R8G8_B8G8_UNORM,
    D3DX_PIXEL_FORMAT_G8R8_G8B8_UNORM,
    D3DX_PIXEL_FORMAT_UYVY,
    D3DX_PIXEL_FORMAT_YUY2,
    D3DX_PIXEL_FORMAT_COUNT,
};

format_flag

enum format_flag

Enumerator
FMT_FLAG_DXT
FMT_FLAG_PACKED
FMT_FLAG_INTERNAL

Definition at line 155 of file d3dx9_private.h.

{
    FMT_FLAG_DXT  = 0x01,
    FMT_FLAG_PACKED = 0x02,
    /* Internal only format, has no exact D3DFORMAT equivalent. */
    FMT_FLAG_INTERNAL = 0x04,
};

pres_reg_tables

enum pres_reg_tables

Enumerator
PRES_REGTAB_IMMED
PRES_REGTAB_CONST
PRES_REGTAB_INPUT
PRES_REGTAB_OCONST
PRES_REGTAB_OBCONST
PRES_REGTAB_OICONST
PRES_REGTAB_TEMP
PRES_REGTAB_COUNT
PRES_REGTAB_FIRST_SHADER

Definition at line 437 of file d3dx9_private.h.

{
    PRES_REGTAB_IMMED,
    PRES_REGTAB_CONST,
    PRES_REGTAB_INPUT,
    PRES_REGTAB_OCONST,
    PRES_REGTAB_OBCONST,
    PRES_REGTAB_OICONST,
    PRES_REGTAB_TEMP,
    PRES_REGTAB_COUNT,
    PRES_REGTAB_FIRST_SHADER = PRES_REGTAB_CONST,
};

range

enum typedef GLsizei range

Enumerator
RANGE_FULL
RANGE_UNORM
RANGE_SNORM

Definition at line 58 of file d3dx9_private.h.

           {
    RANGE_FULL  = 0,
    RANGE_UNORM = 1,
    RANGE_SNORM = 2,
};

Function Documentation

convert_argb_pixels()

void convert_argb_pixels	(	const BYTE *	src,
		UINT	src_row_pitch,
		UINT	src_slice_pitch,
		const struct volume *	src_size,
		const struct pixel_format_desc *	src_format,
		BYTE *	dst,
		UINT	dst_row_pitch,
		UINT	dst_slice_pitch,
		const struct volume *	dst_size,
		const struct pixel_format_desc *	dst_format,
		D3DCOLOR	color_key,
		const PALETTEENTRY *	palette
	)

Definition at line 2180 of file surface.c.

{
    struct argb_conversion_info conv_info, ck_conv_info;
    const struct pixel_format_desc *ck_format;
    DWORD channels[4];
    UINT min_width, min_height, min_depth;
    UINT x, y, z;
 
    TRACE("src %p, src_row_pitch %u, src_slice_pitch %u, src_size %p, src_format %p, dst %p, "
            "dst_row_pitch %u, dst_slice_pitch %u, dst_size %p, dst_format %p, color_key 0x%08lx, palette %p.\n",
            src, src_row_pitch, src_slice_pitch, src_size, src_format, dst, dst_row_pitch, dst_slice_pitch, dst_size,
            dst_format, color_key, palette);
 
    ZeroMemory(channels, sizeof(channels));
    init_argb_conversion_info(src_format, dst_format, &conv_info);
 
    min_width = min(src_size->width, dst_size->width);
    min_height = min(src_size->height, dst_size->height);
    min_depth = min(src_size->depth, dst_size->depth);
 
    if (color_key)
    {
        /* Color keys are always represented in D3DFMT_A8R8G8B8 format. */
        ck_format = get_format_info(D3DFMT_A8R8G8B8);
        init_argb_conversion_info(src_format, ck_format, &ck_conv_info);
    }
 
    for (z = 0; z < min_depth; z++) {
        const BYTE *src_slice_ptr = src + z * src_slice_pitch;
        BYTE *dst_slice_ptr = dst + z * dst_slice_pitch;
 
        for (y = 0; y < min_height; y++) {
            const BYTE *src_ptr = src_slice_ptr + y * src_row_pitch;
            BYTE *dst_ptr = dst_slice_ptr + y * dst_row_pitch;
 
            for (x = 0; x < min_width; x++) {
                if (format_types_match(src_format, dst_format)
                        && src_format->bytes_per_pixel <= 4 && dst_format->bytes_per_pixel <= 4)
                {
                    DWORD val;
 
                    get_relevant_argb_components(&conv_info, src_ptr, channels);
                    val = make_argb_color(&conv_info, channels);
 
                    if (color_key)
                    {
                        DWORD ck_pixel;
 
                        get_relevant_argb_components(&ck_conv_info, src_ptr, channels);
                        ck_pixel = make_argb_color(&ck_conv_info, channels);
                        if (ck_pixel == color_key)
                            val &= ~conv_info.destmask[0];
                    }
                    memcpy(dst_ptr, &val, dst_format->bytes_per_pixel);
                }
                else
                {
                    struct d3dx_color color, tmp;
 
                    format_to_d3dx_color(src_format, src_ptr, palette, &color);
                    tmp = color;
 
                    if (color_key)
                    {
                        DWORD ck_pixel;
 
                        format_from_d3dx_color(ck_format, &tmp, (BYTE *)&ck_pixel);
                        if (ck_pixel == color_key)
                            tmp.value.w = 0.0f;
                    }
 
                    color = tmp;
                    format_from_d3dx_color(dst_format, &color, dst_ptr);
                }
 
                src_ptr += src_format->bytes_per_pixel;
                dst_ptr += dst_format->bytes_per_pixel;
            }
 
            if (src_size->width < dst_size->width) /* black out remaining pixels */
                memset(dst_ptr, 0, dst_format->bytes_per_pixel * (dst_size->width - src_size->width));
        }
 
        if (src_size->height < dst_size->height) /* black out remaining pixels */
            memset(dst + src_size->height * dst_row_pitch, 0, dst_row_pitch * (dst_size->height - src_size->height));
    }
    if (src_size->depth < dst_size->depth) /* black out remaining pixels */
        memset(dst + src_size->depth * dst_slice_pitch, 0, dst_slice_pitch * (dst_size->depth - src_size->depth));
}

Referenced by d3dx_image_tga_decode(), d3dx_load_pixels_from_pixels(), and D3DXSaveSurfaceToFileInMemory().

copy_pixels()

void copy_pixels	(	const BYTE *	src,
		UINT	src_row_pitch,
		UINT	src_slice_pitch,
		BYTE *	dst,
		UINT	dst_row_pitch,
		UINT	dst_slice_pitch,
		const struct volume *	size,
		const struct pixel_format_desc *	format
	)

Definition at line 2149 of file surface.c.

{
    UINT row, slice;
    BYTE *dst_addr;
    const BYTE *src_addr;
    UINT row_block_count = (size->width + format->block_width - 1) / format->block_width;
    UINT row_count = (size->height + format->block_height - 1) / format->block_height;
 
    for (slice = 0; slice < size->depth; slice++)
    {
        src_addr = src + slice * src_slice_pitch;
        dst_addr = dst + slice * dst_slice_pitch;
 
        for (row = 0; row < row_count; row++)
        {
            memcpy(dst_addr, src_addr, row_block_count * format->block_byte_count);
            src_addr += src_row_pitch;
            dst_addr += dst_row_pitch;
        }
    }
}

Referenced by BitmapImpl_CopyPixels(), BmpFrameDecode_CopyPixels(), d3dx_load_pixels_from_pixels(), DdsFrameDecode_CopyPixels(), DdsFrameDecode_Dds_CopyBlocks(), GifFrameDecode_CopyPixels(), IcoFrameDecode_CopyPixels(), jpeg_decoder_copy_pixels(), png_decoder_copy_pixels(), test_dds_decoder_frame_data(), TgaDecoder_Frame_CopyPixels(), and tiff_decoder_copy_pixels().

d3dformat_from_d3dx_pixel_format_id()

D3DFORMAT d3dformat_from_d3dx_pixel_format_id

(

enum d3dx_pixel_format_id

format

)

Definition at line 83 of file util.c.

{
    switch (format)
    {
        case D3DX_PIXEL_FORMAT_B8G8R8_UNORM:             return D3DFMT_R8G8B8;
        case D3DX_PIXEL_FORMAT_B8G8R8A8_UNORM:           return D3DFMT_A8R8G8B8;
        case D3DX_PIXEL_FORMAT_B8G8R8X8_UNORM:           return D3DFMT_X8R8G8B8;
        case D3DX_PIXEL_FORMAT_R8G8B8A8_UNORM:           return D3DFMT_A8B8G8R8;
        case D3DX_PIXEL_FORMAT_R8G8B8X8_UNORM:           return D3DFMT_X8B8G8R8;
        case D3DX_PIXEL_FORMAT_B5G6R5_UNORM:             return D3DFMT_R5G6B5;
        case D3DX_PIXEL_FORMAT_B5G5R5X1_UNORM:           return D3DFMT_X1R5G5B5;
        case D3DX_PIXEL_FORMAT_B5G5R5A1_UNORM:           return D3DFMT_A1R5G5B5;
        case D3DX_PIXEL_FORMAT_B2G3R3_UNORM:             return D3DFMT_R3G3B2;
        case D3DX_PIXEL_FORMAT_B2G3R3A8_UNORM:           return D3DFMT_A8R3G3B2;
        case D3DX_PIXEL_FORMAT_B4G4R4A4_UNORM:           return D3DFMT_A4R4G4B4;
        case D3DX_PIXEL_FORMAT_B4G4R4X4_UNORM:           return D3DFMT_X4R4G4B4;
        case D3DX_PIXEL_FORMAT_B10G10R10A2_UNORM:        return D3DFMT_A2R10G10B10;
        case D3DX_PIXEL_FORMAT_R10G10B10A2_UNORM:        return D3DFMT_A2B10G10R10;
        case D3DX_PIXEL_FORMAT_R16G16B16A16_UNORM:       return D3DFMT_A16B16G16R16;
        case D3DX_PIXEL_FORMAT_R16G16_UNORM:             return D3DFMT_G16R16;
        case D3DX_PIXEL_FORMAT_A8_UNORM:                 return D3DFMT_A8;
        case D3DX_PIXEL_FORMAT_L8A8_UNORM:               return D3DFMT_A8L8;
        case D3DX_PIXEL_FORMAT_L4A4_UNORM:               return D3DFMT_A4L4;
        case D3DX_PIXEL_FORMAT_L8_UNORM:                 return D3DFMT_L8;
        case D3DX_PIXEL_FORMAT_L16_UNORM:                return D3DFMT_L16;
        case D3DX_PIXEL_FORMAT_DXT1_UNORM:               return D3DFMT_DXT1;
        case D3DX_PIXEL_FORMAT_DXT2_UNORM:               return D3DFMT_DXT2;
        case D3DX_PIXEL_FORMAT_DXT3_UNORM:               return D3DFMT_DXT3;
        case D3DX_PIXEL_FORMAT_DXT4_UNORM:               return D3DFMT_DXT4;
        case D3DX_PIXEL_FORMAT_DXT5_UNORM:               return D3DFMT_DXT5;
        case D3DX_PIXEL_FORMAT_R16_FLOAT:                return D3DFMT_R16F;
        case D3DX_PIXEL_FORMAT_R16G16_FLOAT:             return D3DFMT_G16R16F;
        case D3DX_PIXEL_FORMAT_R16G16B16A16_FLOAT:       return D3DFMT_A16B16G16R16F;
        case D3DX_PIXEL_FORMAT_R32_FLOAT:                return D3DFMT_R32F;
        case D3DX_PIXEL_FORMAT_R32G32_FLOAT:             return D3DFMT_G32R32F;
        case D3DX_PIXEL_FORMAT_R32G32B32A32_FLOAT:       return D3DFMT_A32B32G32R32F;
        case D3DX_PIXEL_FORMAT_P8_UINT:                  return D3DFMT_P8;
        case D3DX_PIXEL_FORMAT_P8_UINT_A8_UNORM:         return D3DFMT_A8P8;
        case D3DX_PIXEL_FORMAT_U8V8W8Q8_SNORM:           return D3DFMT_Q8W8V8U8;
        case D3DX_PIXEL_FORMAT_U8V8_SNORM:               return D3DFMT_V8U8;
        case D3DX_PIXEL_FORMAT_U16V16_SNORM:             return D3DFMT_V16U16;
        case D3DX_PIXEL_FORMAT_U8V8_SNORM_L8X8_UNORM:    return D3DFMT_X8L8V8U8;
        case D3DX_PIXEL_FORMAT_U10V10W10_SNORM_A2_UNORM: return D3DFMT_A2W10V10U10;
        case D3DX_PIXEL_FORMAT_U16V16W16Q16_SNORM:       return D3DFMT_Q16W16V16U16;
        case D3DX_PIXEL_FORMAT_G8R8_G8B8_UNORM:          return D3DFMT_G8R8_G8B8;
        case D3DX_PIXEL_FORMAT_R8G8_B8G8_UNORM:          return D3DFMT_R8G8_B8G8;
        case D3DX_PIXEL_FORMAT_UYVY:                     return D3DFMT_UYVY;
        case D3DX_PIXEL_FORMAT_YUY2:                     return D3DFMT_YUY2;
        default:
            if (!is_internal_format(get_d3dx_pixel_format_info(format)))
                FIXME("Unknown d3dx_pixel_format_id %u.\n", format);
            return D3DFMT_UNKNOWN;
    }
}

Referenced by check_texture_requirements(), d3dximage_info_from_d3dx_image(), and D3DXSaveSurfaceToFileInMemory().

d3dx9_handle_load_filter()

static HRESULT d3dx9_handle_load_filter ( DWORD *  filter )

inlinestatic

Definition at line 45 of file d3dx9_private.h.

{
    if (*filter == D3DX_DEFAULT)
        *filter = D3DX_FILTER_TRIANGLE | D3DX_FILTER_DITHER;
 
    return d3dx9_validate_filter(*filter);
}

Referenced by D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), D3DXCreateVolumeTextureFromFileInMemoryEx(), D3DXLoadSurfaceFromFileInMemory(), D3DXLoadSurfaceFromMemory(), D3DXLoadSurfaceFromSurface(), D3DXLoadVolumeFromFileInMemory(), D3DXLoadVolumeFromMemory(), and D3DXLoadVolumeFromVolume().

d3dx9_validate_filter()

static HRESULT d3dx9_validate_filter ( uint32_t  filter )

inlinestatic

Definition at line 37 of file d3dx9_private.h.

{
    if ((filter & D3DX9_FILTER_INVALID_BITS) || !(filter & 0x7) || ((filter & 0x7) > D3DX_FILTER_BOX))
        return D3DERR_INVALIDCALL;
 
    return D3D_OK;
}

Referenced by d3dx9_handle_load_filter(), and D3DXFilterTexture().

d3dx_create_param_eval()

HRESULT d3dx_create_param_eval	(	struct d3dx_parameters_store *	parameters,
		void *	byte_code,
		unsigned int	byte_code_size,
		D3DXPARAMETER_TYPE	type,
		struct d3dx_param_eval **	peval,
		ULONG64 *	version_counter,
		const char **	skip_constants,
		unsigned int	skip_constants_count
	)

Definition at line 1232 of file preshader.c.

{
    struct d3dx_param_eval *peval;
    unsigned int *ptr, *shader_ptr = NULL;
    unsigned int i;
    BOOL shader;
    unsigned int count, pres_size;
    HRESULT ret;
 
    TRACE("parameters %p, byte_code %p, byte_code_size %u, type %u, peval_out %p.\n",
            parameters, byte_code, byte_code_size, type, peval_out);
 
    count = byte_code_size / sizeof(unsigned int);
    if (!byte_code || !count)
    {
        *peval_out = NULL;
        return D3D_OK;
    }
 
    peval = calloc(1, sizeof(*peval));
    if (!peval)
    {
        ret = E_OUTOFMEMORY;
        goto err_out;
    }
    peval->version_counter = version_counter;
 
    peval->param_type = type;
    switch (type)
    {
        case D3DXPT_VERTEXSHADER:
        case D3DXPT_PIXELSHADER:
            shader = TRUE;
            break;
        default:
            shader = FALSE;
            break;
    }
    peval->shader_inputs.regset2table = shad_regset2table;
 
    ptr = (unsigned int *)byte_code;
    if (shader)
    {
        if ((*ptr & 0xfffe0000) != 0xfffe0000)
        {
            FIXME("Invalid shader signature %#x.\n", *ptr);
            ret = D3DXERR_INVALIDDATA;
            goto err_out;
        }
        TRACE("Shader version %#x.\n", *ptr & 0xffff);
        shader_ptr = ptr;
        ptr = find_bytecode_comment(ptr + 1, count - 1, FOURCC_PRES, &pres_size);
        if (!ptr)
            TRACE("No preshader found.\n");
    }
    else
    {
        pres_size = count;
    }
 
    if (ptr && FAILED(ret = parse_preshader(&peval->pres, ptr, pres_size, parameters)))
    {
        FIXME("Failed parsing preshader, byte code for analysis follows.\n");
        dump_bytecode(byte_code, byte_code_size);
        goto err_out;
    }
 
    if (shader)
    {
        if (FAILED(ret = get_constants_desc(shader_ptr, &peval->shader_inputs, parameters,
                skip_constants, skip_constants_count, &peval->pres)))
        {
            TRACE("Could not get shader constant table, hr %#lx.\n", ret);
            goto err_out;
        }
        update_table_sizes_consts(peval->pres.regs.table_sizes, &peval->shader_inputs);
    }
 
    for (i = PRES_REGTAB_FIRST_SHADER; i < PRES_REGTAB_COUNT; ++i)
    {
        if (FAILED(ret = regstore_alloc_table(&peval->pres.regs, i)))
            goto err_out;
    }
 
    if (TRACE_ON(d3dx))
    {
        dump_bytecode(byte_code, byte_code_size);
        dump_preshader(&peval->pres);
        if (shader)
        {
            TRACE("// Shader registers:\n");
            dump_registers(&peval->shader_inputs);
        }
    }
    *peval_out = peval;
    TRACE("Created parameter evaluator %p.\n", *peval_out);
    return D3D_OK;
 
err_out:
    WARN("Error creating parameter evaluator.\n");
    if (TRACE_ON(d3dx))
        dump_bytecode(byte_code, byte_code_size);
 
    d3dx_free_param_eval(peval);
    *peval_out = NULL;
    return ret;
}

Referenced by d3dx_parse_array_selector(), d3dx_parse_resource(), and D3DXCreateTextureShader().

d3dx_evaluate_parameter()

HRESULT d3dx_evaluate_parameter	(	struct d3dx_param_eval *	peval,
		const struct d3dx_parameter *	param,
		void *	param_value
	)

Definition at line 1722 of file preshader.c.

{
    HRESULT hr;
    unsigned int i;
    unsigned int elements, elements_param, elements_table;
    BOOL is_dirty;
    float *oc;
 
    TRACE("peval %p, param %p, param_value %p.\n", peval, param, param_value);
 
    if ((is_dirty = is_const_tab_input_dirty(&peval->pres.inputs, ULONG64_MAX)))
    {
        set_constants(&peval->pres.regs, &peval->pres.inputs,
                next_update_version(peval->version_counter), NULL, NULL,
                peval->param_type, FALSE, FALSE);
    }
 
    if (is_dirty || peval->pres.regs.table_sizes[PRES_REGTAB_INPUT])
    {
        if (FAILED(hr = execute_preshader(&peval->pres)))
            return hr;
    }
 
    elements_table = get_offset_reg(PRES_REGTAB_OCONST, peval->pres.regs.table_sizes[PRES_REGTAB_OCONST]);
    elements_param = param->bytes / sizeof(unsigned int);
    elements = min(elements_table, elements_param);
    oc = (float *)peval->pres.regs.tables[PRES_REGTAB_OCONST];
    for (i = 0; i < elements; ++i)
        set_number((unsigned int *)param_value + i, param->type, oc + i, D3DXPT_FLOAT);
    return D3D_OK;
}

Referenced by d3dx9_get_param_value_ptr(), texture_shader_fill_2d(), and texture_shader_fill_3d().

d3dx_free_param_eval()

void d3dx_free_param_eval

(

struct d3dx_param_eval *

peval

)

Definition at line 1357 of file preshader.c.

{
    TRACE("peval %p.\n", peval);
 
    if (!peval)
        return;
 
    d3dx_free_preshader(&peval->pres);
    d3dx_free_const_tab(&peval->shader_inputs);
    free(peval);
}

Referenced by d3dx9_texture_shader_Release(), d3dx_create_param_eval(), and free_parameter().

d3dx_image_cleanup()

void d3dx_image_cleanup

(

struct d3dx_image *

image

)

Definition at line 1392 of file surface.c.

{
    free(image->image_buf);
    free(image->image_palette);
}

Referenced by D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), D3DXCreateVolumeTextureFromFileInMemoryEx(), D3DXLoadSurfaceFromFileInMemory(), and D3DXLoadVolumeFromFileInMemory().

d3dx_image_get_pixels()

HRESULT d3dx_image_get_pixels	(	struct d3dx_image *	image,
		uint32_t	layer,
		uint32_t	mip_level,
		struct d3dx_pixels *	pixels
	)

Definition at line 1398 of file surface.c.

{
    struct volume mip_level_size = image->size;
    const BYTE *pixels_ptr = image->pixels;
    uint32_t row_pitch, slice_pitch, i;
    RECT unaligned_rect;
    HRESULT hr = S_OK;
 
    if (mip_level >= image->mip_levels)
    {
        ERR("Tried to retrieve mip level %u, but image only has %u mip levels.\n", mip_level, image->mip_levels);
        return E_FAIL;
    }
 
    if (layer >= image->layer_count)
    {
        ERR("Tried to retrieve layer %u, but image only has %u layers.\n", layer, image->layer_count);
        return E_FAIL;
    }
 
    slice_pitch = row_pitch = 0;
    for (i = 0; i < image->mip_levels; i++)
    {
        hr = d3dx_calculate_pixels_size(image->format, mip_level_size.width, mip_level_size.height, &row_pitch, &slice_pitch);
        if (FAILED(hr))
            return hr;
 
        if (i == mip_level)
            break;
 
        pixels_ptr += slice_pitch * mip_level_size.depth;
        d3dx_get_next_mip_level_size(&mip_level_size);
    }
 
    pixels_ptr += (layer * image->layer_pitch);
    SetRect(&unaligned_rect, 0, 0, mip_level_size.width, mip_level_size.height);
    set_d3dx_pixels(pixels, pixels_ptr, row_pitch, slice_pitch, image->palette, mip_level_size.width,
            mip_level_size.height, mip_level_size.depth, &unaligned_rect);
 
    return D3D_OK;
}

Referenced by D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), D3DXCreateVolumeTextureFromFileInMemoryEx(), D3DXLoadSurfaceFromFileInMemory(), and D3DXLoadVolumeFromFileInMemory().

d3dx_image_init()

HRESULT d3dx_image_init	(	const void *	src_data,
		uint32_t	src_data_size,
		struct d3dx_image *	image,
		uint32_t	starting_mip_level,
		uint32_t	flags
	)

Definition at line 1332 of file surface.c.

{
    D3DXIMAGE_FILEFORMAT iff = D3DXIFF_FORCE_DWORD;
    HRESULT hr;
 
    if (!src_data || !src_data_size || !image)
        return D3DERR_INVALIDCALL;
 
    memset(image, 0, sizeof(*image));
    if (!d3dx_get_image_file_format_from_file_signature(src_data, src_data_size, &iff))
    {
        uint32_t src_image_size = src_data_size;
        const void *src_image = src_data;
 
        if (convert_dib_to_bmp(&src_image, &src_image_size))
        {
            hr = d3dx_image_init(src_image, src_image_size, image, starting_mip_level, flags);
            free((void *)src_image);
            if (SUCCEEDED(hr))
                image->image_file_format = D3DXIFF_DIB;
            return hr;
        }
 
        /* Last resort, try TGA. */
        return d3dx_initialize_image_from_tga(src_data, src_data_size, image, flags);
    }
 
    switch (iff)
    {
        case D3DXIFF_BMP:
        case D3DXIFF_JPG:
        case D3DXIFF_PNG:
            hr = d3dx_initialize_image_from_wic(src_data, src_data_size, image, iff, flags);
            break;
 
        case D3DXIFF_DDS:
            hr = d3dx_initialize_image_from_dds(src_data, src_data_size, image, starting_mip_level);
            break;
 
        case D3DXIFF_PPM:
        case D3DXIFF_HDR:
        case D3DXIFF_PFM:
            WARN("Unsupported file format %s.\n", debug_d3dx_image_file_format(iff));
            hr = E_NOTIMPL;
            break;
 
        case D3DXIFF_FORCE_DWORD:
            ERR("Unrecognized file format.\n");
            hr = D3DXERR_INVALIDDATA;
            break;
 
        default:
            assert(0);
            return E_FAIL;
    }
 
    return hr;
}

Referenced by d3dx_image_init(), D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), D3DXCreateVolumeTextureFromFileInMemoryEx(), D3DXGetImageInfoFromFileInMemory(), D3DXLoadSurfaceFromFileInMemory(), and D3DXLoadVolumeFromFileInMemory().

d3dx_init_parameters_store()

HRESULT d3dx_init_parameters_store	(	struct d3dx_parameters_store *	store,
		unsigned int	count
	)

Definition at line 743 of file effect.c.

{
    store->count = count;
    wine_rb_init(&store->tree, param_rb_compare);
 
    if (store->count && !(store->parameters = calloc(store->count, sizeof(*store->parameters))))
        return E_OUTOFMEMORY;
 
    return S_OK;
}

Referenced by d3dx_parse_effect(), and D3DXCreateTextureShader().

d3dx_load_pixels_from_pixels()

HRESULT d3dx_load_pixels_from_pixels	(	struct d3dx_pixels *	dst_pixels,
		const struct pixel_format_desc *	dst_desc,
		struct d3dx_pixels *	src_pixels,
		const struct pixel_format_desc *	src_desc,
		uint32_t	filter_flags,
		uint32_t	color_key
	)

Definition at line 2498 of file surface.c.

{
    struct volume src_size, dst_size, dst_size_aligned;
    HRESULT hr = S_OK;
 
    TRACE("dst_pixels %s, dst_desc %p, src_pixels %s, src_desc %p, filter_flags %#x, color_key %#x.\n",
            debug_d3dx_pixels(dst_pixels), dst_desc, debug_d3dx_pixels(src_pixels), src_desc,
            filter_flags, color_key);
 
    if (is_compressed_format(src_desc))
        set_volume_struct(&src_size, (src_pixels->unaligned_rect.right - src_pixels->unaligned_rect.left),
                (src_pixels->unaligned_rect.bottom - src_pixels->unaligned_rect.top), src_pixels->size.depth);
    else
        src_size = src_pixels->size;
 
    dst_size_aligned = dst_pixels->size;
    if (is_compressed_format(dst_desc))
        set_volume_struct(&dst_size, (dst_pixels->unaligned_rect.right - dst_pixels->unaligned_rect.left),
                (dst_pixels->unaligned_rect.bottom - dst_pixels->unaligned_rect.top), dst_pixels->size.depth);
    else
        dst_size = dst_size_aligned;
 
    /* Everything matches, simply copy the pixels. */
    if (src_desc->format == dst_desc->format
            && (dst_size.width == src_size.width && !(dst_size.width % dst_desc->block_width))
            && (dst_size.height == src_size.height && !(dst_size.height % dst_desc->block_height))
            && (dst_size.depth == src_size.depth)
            && color_key == 0
            && !(src_pixels->unaligned_rect.left & (src_desc->block_width - 1))
            && !(src_pixels->unaligned_rect.top & (src_desc->block_height - 1))
            && !(dst_pixels->unaligned_rect.left & (dst_desc->block_width - 1))
            && !(dst_pixels->unaligned_rect.top & (dst_desc->block_height - 1)))
    {
        TRACE("Simple copy.\n");
        copy_pixels(src_pixels->data, src_pixels->row_pitch, src_pixels->slice_pitch, (void *)dst_pixels->data,
                dst_pixels->row_pitch, dst_pixels->slice_pitch, &src_size, src_desc);
        return S_OK;
    }
 
    /* Stretching or format conversion. */
    if (!is_conversion_from_supported(src_desc)
            || !is_conversion_to_supported(dst_desc))
    {
        FIXME("Unsupported format conversion %#x -> %#x.\n", src_desc->format, dst_desc->format);
        return E_NOTIMPL;
    }
 
    /*
     * If the source is a compressed image, we need to decompress it first
     * before doing any modifications.
     */
    if (is_compressed_format(src_desc))
    {
        uint32_t uncompressed_row_pitch, uncompressed_slice_pitch;
        const struct pixel_format_desc *uncompressed_desc;
        void *uncompressed_mem = NULL;
 
        hr = d3dx_pixels_decompress(src_pixels, src_desc, FALSE, &uncompressed_mem, &uncompressed_row_pitch,
                &uncompressed_slice_pitch, &uncompressed_desc);
        if (SUCCEEDED(hr))
        {
            struct d3dx_pixels uncompressed_pixels;
 
            d3dx_pixels_init(uncompressed_mem, uncompressed_row_pitch, uncompressed_slice_pitch, NULL,
                    uncompressed_desc->format, 0, 0, src_pixels->size.width, src_pixels->size.height,
                    0, src_pixels->size.depth, &uncompressed_pixels);
 
            hr = d3dx_load_pixels_from_pixels(dst_pixels, dst_desc, &uncompressed_pixels, uncompressed_desc,
                    filter_flags, color_key);
        }
        free(uncompressed_mem);
        goto exit;
    }
 
    /* Same as the above, need to decompress the destination prior to modifying. */
    if (is_compressed_format(dst_desc))
    {
        uint32_t uncompressed_row_pitch, uncompressed_slice_pitch;
        const struct pixel_format_desc *uncompressed_desc;
        struct d3dx_pixels uncompressed_pixels;
        void *uncompressed_mem = NULL;
 
        hr = d3dx_pixels_decompress(dst_pixels, dst_desc, TRUE, &uncompressed_mem, &uncompressed_row_pitch,
                &uncompressed_slice_pitch, &uncompressed_desc);
        if (FAILED(hr))
            goto exit;
 
        d3dx_pixels_init(uncompressed_mem, uncompressed_row_pitch, uncompressed_slice_pitch, NULL,
                uncompressed_desc->format, dst_pixels->unaligned_rect.left, dst_pixels->unaligned_rect.top,
                dst_pixels->unaligned_rect.right, dst_pixels->unaligned_rect.bottom, 0, dst_pixels->size.depth,
                &uncompressed_pixels);
 
        hr = d3dx_load_pixels_from_pixels(&uncompressed_pixels, uncompressed_desc, src_pixels, src_desc, filter_flags,
                color_key);
        if (SUCCEEDED(hr))
        {
            GLenum gl_format = 0;
            uint32_t i;
 
            TRACE("Compressing DXTn surface.\n");
            switch (dst_desc->format)
            {
                case D3DX_PIXEL_FORMAT_DXT1_UNORM:
                    gl_format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
                    break;
                case D3DX_PIXEL_FORMAT_DXT2_UNORM:
                case D3DX_PIXEL_FORMAT_DXT3_UNORM:
                    gl_format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
                    break;
                case D3DX_PIXEL_FORMAT_DXT4_UNORM:
                case D3DX_PIXEL_FORMAT_DXT5_UNORM:
                    gl_format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
                    break;
                default:
                    ERR("Unexpected destination compressed format %u.\n", dst_desc->format);
            }
 
            for (i = 0; i < dst_size_aligned.depth; ++i)
            {
                BYTE *uncompressed_mem_slice = (BYTE *)uncompressed_mem + (i * uncompressed_slice_pitch);
                BYTE *dst_memory_slice = ((BYTE *)dst_pixels->data) + (i * dst_pixels->slice_pitch);
 
                tx_compress_dxtn(4, dst_size_aligned.width, dst_size_aligned.height, uncompressed_mem_slice, gl_format,
                        dst_memory_slice, dst_pixels->row_pitch);
            }
        }
        free(uncompressed_mem);
        goto exit;
    }
 
    if ((filter_flags & 0xf) == D3DX_FILTER_NONE)
    {
        convert_argb_pixels(src_pixels->data, src_pixels->row_pitch, src_pixels->slice_pitch, &src_size, src_desc,
                (BYTE *)dst_pixels->data, dst_pixels->row_pitch, dst_pixels->slice_pitch, &dst_size, dst_desc,
                color_key, src_pixels->palette);
    }
    else /* if ((filter & 0xf) == D3DX_FILTER_POINT) */
    {
        if ((filter_flags & 0xf) != D3DX_FILTER_POINT)
            FIXME("Unhandled filter %#x.\n", filter_flags);
 
        /* Always apply a point filter until D3DX_FILTER_LINEAR,
         * D3DX_FILTER_TRIANGLE and D3DX_FILTER_BOX are implemented. */
        point_filter_argb_pixels(src_pixels->data, src_pixels->row_pitch, src_pixels->slice_pitch, &src_size,
                src_desc, (BYTE *)dst_pixels->data, dst_pixels->row_pitch, dst_pixels->slice_pitch, &dst_size,
                dst_desc, color_key, src_pixels->palette);
    }
 
exit:
    if (FAILED(hr))
        WARN("Failed to load pixels, hr %#lx.\n", hr);
    return hr;
}

Referenced by d3dx_load_pixels_from_pixels(), d3dx_load_surface_from_memory(), d3dx_load_volume_from_memory(), d3dx_save_pixels_to_memory(), D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), and D3DXCreateVolumeTextureFromFileInMemoryEx().

d3dx_param_eval_set_shader_constants()

HRESULT d3dx_param_eval_set_shader_constants	(	ID3DXEffectStateManager *	manager,
		struct IDirect3DDevice9 *	device,
		struct d3dx_param_eval *	peval,
		BOOL	update_all
	)

Definition at line 1755 of file preshader.c.

{
    HRESULT hr;
    struct d3dx_preshader *pres = &peval->pres;
    struct d3dx_regstore *rs = &pres->regs;
    ULONG64 new_update_version = next_update_version(peval->version_counter);
    BOOL pres_dirty = FALSE;
 
    TRACE("device %p, peval %p, param_type %u.\n", device, peval, peval->param_type);
 
    if (is_const_tab_input_dirty(&pres->inputs, ULONG64_MAX))
    {
        set_constants(rs, &pres->inputs, new_update_version,
                NULL, NULL, peval->param_type, FALSE, FALSE);
        if (FAILED(hr = execute_preshader(pres)))
            return hr;
        pres_dirty = TRUE;
    }
 
    return set_constants(rs, &peval->shader_inputs, new_update_version,
            manager, device, peval->param_type, update_all, pres_dirty);
}

Referenced by d3dx_set_shader_constants().

d3dx_parameters_store_cleanup()

void d3dx_parameters_store_cleanup

(

struct d3dx_parameters_store *

store

)

Definition at line 754 of file effect.c.

{
    unsigned int i;
 
    free(store->full_name_tmp);
 
    if (store->parameters)
    {
        for (i = 0; i < store->count; ++i)
            free_top_level_parameter(&store->parameters[i]);
        free(store->parameters);
        store->parameters = NULL;
    }
}

Referenced by d3dx9_texture_shader_Release(), d3dx_effect_cleanup(), and d3dx_parse_effect().

d3dx_pixel_format_id_from_d3dformat()

enum d3dx_pixel_format_id d3dx_pixel_format_id_from_d3dformat

(

D3DFORMAT

format

)

Definition at line 138 of file util.c.

{
    switch (format)
    {
        case D3DFMT_R8G8B8:        return D3DX_PIXEL_FORMAT_B8G8R8_UNORM;
        case D3DFMT_A8R8G8B8:      return D3DX_PIXEL_FORMAT_B8G8R8A8_UNORM;
        case D3DFMT_X8R8G8B8:      return D3DX_PIXEL_FORMAT_B8G8R8X8_UNORM;
        case D3DFMT_A8B8G8R8:      return D3DX_PIXEL_FORMAT_R8G8B8A8_UNORM;
        case D3DFMT_X8B8G8R8:      return D3DX_PIXEL_FORMAT_R8G8B8X8_UNORM;
        case D3DFMT_R5G6B5:        return D3DX_PIXEL_FORMAT_B5G6R5_UNORM;
        case D3DFMT_X1R5G5B5:      return D3DX_PIXEL_FORMAT_B5G5R5X1_UNORM;
        case D3DFMT_A1R5G5B5:      return D3DX_PIXEL_FORMAT_B5G5R5A1_UNORM;
        case D3DFMT_R3G3B2:        return D3DX_PIXEL_FORMAT_B2G3R3_UNORM;
        case D3DFMT_A8R3G3B2:      return D3DX_PIXEL_FORMAT_B2G3R3A8_UNORM;
        case D3DFMT_A4R4G4B4:      return D3DX_PIXEL_FORMAT_B4G4R4A4_UNORM;
        case D3DFMT_X4R4G4B4:      return D3DX_PIXEL_FORMAT_B4G4R4X4_UNORM;
        case D3DFMT_A2R10G10B10:   return D3DX_PIXEL_FORMAT_B10G10R10A2_UNORM;
        case D3DFMT_A2B10G10R10:   return D3DX_PIXEL_FORMAT_R10G10B10A2_UNORM;
        case D3DFMT_A16B16G16R16:  return D3DX_PIXEL_FORMAT_R16G16B16A16_UNORM;
        case D3DFMT_G16R16:        return D3DX_PIXEL_FORMAT_R16G16_UNORM;
        case D3DFMT_A8:            return D3DX_PIXEL_FORMAT_A8_UNORM;
        case D3DFMT_A8L8:          return D3DX_PIXEL_FORMAT_L8A8_UNORM;
        case D3DFMT_A4L4:          return D3DX_PIXEL_FORMAT_L4A4_UNORM;
        case D3DFMT_L8:            return D3DX_PIXEL_FORMAT_L8_UNORM;
        case D3DFMT_L16:           return D3DX_PIXEL_FORMAT_L16_UNORM;
        case D3DFMT_DXT1:          return D3DX_PIXEL_FORMAT_DXT1_UNORM;
        case D3DFMT_DXT2:          return D3DX_PIXEL_FORMAT_DXT2_UNORM;
        case D3DFMT_DXT3:          return D3DX_PIXEL_FORMAT_DXT3_UNORM;
        case D3DFMT_DXT4:          return D3DX_PIXEL_FORMAT_DXT4_UNORM;
        case D3DFMT_DXT5:          return D3DX_PIXEL_FORMAT_DXT5_UNORM;
        case D3DFMT_R16F:          return D3DX_PIXEL_FORMAT_R16_FLOAT;
        case D3DFMT_G16R16F:       return D3DX_PIXEL_FORMAT_R16G16_FLOAT;
        case D3DFMT_A16B16G16R16F: return D3DX_PIXEL_FORMAT_R16G16B16A16_FLOAT;
        case D3DFMT_R32F:          return D3DX_PIXEL_FORMAT_R32_FLOAT;
        case D3DFMT_G32R32F:       return D3DX_PIXEL_FORMAT_R32G32_FLOAT;
        case D3DFMT_A32B32G32R32F: return D3DX_PIXEL_FORMAT_R32G32B32A32_FLOAT;
        case D3DFMT_P8:            return D3DX_PIXEL_FORMAT_P8_UINT;
        case D3DFMT_A8P8:          return D3DX_PIXEL_FORMAT_P8_UINT_A8_UNORM;
        case D3DFMT_Q8W8V8U8:      return D3DX_PIXEL_FORMAT_U8V8W8Q8_SNORM;
        case D3DFMT_V8U8:          return D3DX_PIXEL_FORMAT_U8V8_SNORM;
        case D3DFMT_V16U16:        return D3DX_PIXEL_FORMAT_U16V16_SNORM;
        case D3DFMT_X8L8V8U8:      return D3DX_PIXEL_FORMAT_U8V8_SNORM_L8X8_UNORM;
        case D3DFMT_A2W10V10U10:   return D3DX_PIXEL_FORMAT_U10V10W10_SNORM_A2_UNORM;
        case D3DFMT_Q16W16V16U16:  return D3DX_PIXEL_FORMAT_U16V16W16Q16_SNORM;
        case D3DFMT_R8G8_B8G8:     return D3DX_PIXEL_FORMAT_R8G8_B8G8_UNORM;
        case D3DFMT_G8R8_G8B8:     return D3DX_PIXEL_FORMAT_G8R8_G8B8_UNORM;
        case D3DFMT_UYVY:          return D3DX_PIXEL_FORMAT_UYVY;
        case D3DFMT_YUY2:          return D3DX_PIXEL_FORMAT_YUY2;
        default:
            FIXME("No d3dx_pixel_format_id for D3DFORMAT %s.\n", debugstr_fourcc(format));
            return D3DX_PIXEL_FORMAT_COUNT;
    }
}

Referenced by get_format_info(), and wic_guid_from_d3dformat().

d3dx_pixels_init()

HRESULT d3dx_pixels_init	(	const void *	data,
		uint32_t	row_pitch,
		uint32_t	slice_pitch,
		const PALETTEENTRY *	palette,
		enum d3dx_pixel_format_id	format,
		uint32_t	left,
		uint32_t	top,
		uint32_t	right,
		uint32_t	bottom,
		uint32_t	front,
		uint32_t	back,
		struct d3dx_pixels *	pixels
	)

Definition at line 2450 of file surface.c.

{
    const struct pixel_format_desc *fmt_desc = get_d3dx_pixel_format_info(format);
    const BYTE *ptr = data;
    RECT unaligned_rect;
 
    memset(pixels, 0, sizeof(*pixels));
    if (is_unknown_format(fmt_desc))
    {
        FIXME("Unsupported format %#x.\n", format);
        return E_NOTIMPL;
    }
 
    ptr += front * slice_pitch;
    ptr += (top / fmt_desc->block_height) * row_pitch;
    ptr += (left / fmt_desc->block_width) * fmt_desc->block_byte_count;
 
    if (is_compressed_format(fmt_desc))
    {
        uint32_t left_aligned, top_aligned;
 
        top_aligned = top & ~(fmt_desc->block_height - 1);
        left_aligned = left & ~(fmt_desc->block_width - 1);
        SetRect(&unaligned_rect, left, top, right, bottom);
        OffsetRect(&unaligned_rect, -left_aligned, -top_aligned);
    }
    else
    {
        SetRect(&unaligned_rect, 0, 0, (right - left), (bottom - top));
    }
 
    set_d3dx_pixels(pixels, ptr, row_pitch, slice_pitch, palette, (right - left), (bottom - top), (back - front),
            &unaligned_rect);
 
    return S_OK;
}

Referenced by d3dx_load_pixels_from_pixels(), d3dx_load_surface_from_memory(), d3dx_load_volume_from_memory(), and save_dds_surface_to_memory().

d3dx_shader_get_ctab_constant()

const struct ctab_constant * d3dx_shader_get_ctab_constant	(	ID3DXConstantTable *	iface,
		D3DXHANDLE	constant
	)

Definition at line 969 of file shader.c.

{
    struct ID3DXConstantTableImpl *ctab = impl_from_ID3DXConstantTable(iface);
 
    return get_valid_constant(ctab, constant);
}

Referenced by get_ctab_constant_desc().

d3dximage_info_from_d3dx_image()

void d3dximage_info_from_d3dx_image	(	D3DXIMAGE_INFO *	info,
		struct d3dx_image *	image
	)

Definition at line 1441 of file surface.c.

{
    info->ImageFileFormat = image->image_file_format;
    info->Width = image->size.width;
    info->Height = image->size.height;
    info->Depth = image->size.depth;
    info->MipLevels = image->mip_levels;
    switch (image->format)
    {
        case D3DX_PIXEL_FORMAT_R16G16B16_UNORM:
            info->Format = D3DFMT_A16B16G16R16;
            break;
 
        case D3DX_PIXEL_FORMAT_B8G8R8_UNORM:
            if (info->ImageFileFormat == D3DXIFF_PNG || info->ImageFileFormat == D3DXIFF_JPG)
                info->Format = D3DFMT_X8R8G8B8;
            else
                info->Format = d3dformat_from_d3dx_pixel_format_id(image->format);
            break;
 
        default:
            info->Format = d3dformat_from_d3dx_pixel_format_id(image->format);
            break;
    }
    info->ResourceType = image->resource_type;
}

Referenced by D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), D3DXCreateVolumeTextureFromFileInMemoryEx(), D3DXGetImageInfoFromFileInMemory(), D3DXLoadSurfaceFromFileInMemory(), and D3DXLoadVolumeFromFileInMemory().

debug_d3dxparameter_class()

const char * debug_d3dxparameter_class

(

D3DXPARAMETER_CLASS

c

)

Definition at line 328 of file util.c.

{
    switch (c)
    {
        WINE_D3DX_TO_STR(D3DXPC_SCALAR);
        WINE_D3DX_TO_STR(D3DXPC_VECTOR);
        WINE_D3DX_TO_STR(D3DXPC_MATRIX_ROWS);
        WINE_D3DX_TO_STR(D3DXPC_MATRIX_COLUMNS);
        WINE_D3DX_TO_STR(D3DXPC_OBJECT);
        WINE_D3DX_TO_STR(D3DXPC_STRUCT);
        default:
            FIXME("Unrecognized D3DXPARAMETER_CLASS %#x.\n", c);
            return "unrecognized";
    }
}

Referenced by d3dx_effect_GetMatrix(), d3dx_effect_GetMatrixArray(), d3dx_effect_GetMatrixPointerArray(), d3dx_effect_GetMatrixTranspose(), d3dx_effect_GetMatrixTransposeArray(), d3dx_effect_GetMatrixTransposePointerArray(), d3dx_effect_GetVector(), d3dx_effect_GetVectorArray(), d3dx_effect_SetBoolArray(), d3dx_effect_SetFloatArray(), d3dx_effect_SetIntArray(), d3dx_effect_SetMatrix(), d3dx_effect_SetMatrixArray(), d3dx_effect_SetMatrixPointerArray(), d3dx_effect_SetMatrixTranspose(), d3dx_effect_SetMatrixTransposeArray(), d3dx_effect_SetMatrixTransposePointerArray(), d3dx_effect_SetVector(), d3dx_effect_SetVectorArray(), d3dx_parse_effect_typedef(), d3dx_parse_init_value(), d3dx_parse_resource(), d3dx_parse_value(), ID3DXConstantTableImpl_SetValue(), parse_ctab_constant_type(), set(), set_matrix_array(), set_matrix_pointer_array(), set_scalar(), set_scalar_array(), set_vector(), and set_vector_array().

debug_d3dxparameter_registerset()

const char * debug_d3dxparameter_registerset

(

D3DXREGISTER_SET

r

)

Definition at line 374 of file util.c.

{
    switch (r)
    {
        WINE_D3DX_TO_STR(D3DXRS_BOOL);
        WINE_D3DX_TO_STR(D3DXRS_INT4);
        WINE_D3DX_TO_STR(D3DXRS_FLOAT4);
        WINE_D3DX_TO_STR(D3DXRS_SAMPLER);
        default:
            FIXME("Unrecognized D3DXREGISTER_SET %#x.\n", r);
            return "unrecognized";
    }
}

Referenced by ID3DXConstantTableImpl_SetDefaults(), parse_ctab_constant_type(), and set().

debug_d3dxparameter_type()

const char * debug_d3dxparameter_type

(

D3DXPARAMETER_TYPE

t

)

Definition at line 344 of file util.c.

{
    switch (t)
    {
        WINE_D3DX_TO_STR(D3DXPT_VOID);
        WINE_D3DX_TO_STR(D3DXPT_BOOL);
        WINE_D3DX_TO_STR(D3DXPT_INT);
        WINE_D3DX_TO_STR(D3DXPT_FLOAT);
        WINE_D3DX_TO_STR(D3DXPT_STRING);
        WINE_D3DX_TO_STR(D3DXPT_TEXTURE);
        WINE_D3DX_TO_STR(D3DXPT_TEXTURE1D);
        WINE_D3DX_TO_STR(D3DXPT_TEXTURE2D);
        WINE_D3DX_TO_STR(D3DXPT_TEXTURE3D);
        WINE_D3DX_TO_STR(D3DXPT_TEXTURECUBE);
        WINE_D3DX_TO_STR(D3DXPT_SAMPLER);
        WINE_D3DX_TO_STR(D3DXPT_SAMPLER1D);
        WINE_D3DX_TO_STR(D3DXPT_SAMPLER2D);
        WINE_D3DX_TO_STR(D3DXPT_SAMPLER3D);
        WINE_D3DX_TO_STR(D3DXPT_SAMPLERCUBE);
        WINE_D3DX_TO_STR(D3DXPT_PIXELSHADER);
        WINE_D3DX_TO_STR(D3DXPT_VERTEXSHADER);
        WINE_D3DX_TO_STR(D3DXPT_PIXELFRAGMENT);
        WINE_D3DX_TO_STR(D3DXPT_VERTEXFRAGMENT);
        WINE_D3DX_TO_STR(D3DXPT_UNSUPPORTED);
        default:
            FIXME("Unrecognized D3DXPARAMETER_TYP %#x.\n", t);
            return "unrecognized";
    }
}

Referenced by d3dx_effect_GetValue(), d3dx_parse_effect_typedef(), d3dx_parse_resource(), d3dx_parse_value(), free_parameter(), free_parameter_object_data(), parse_ctab_constant_type(), and set_value().

float_16_to_32()

float float_16_to_32

(

const unsigned short

in

)

Definition at line 2203 of file math.c.

{
    const unsigned short s = (in & 0x8000);
    const unsigned short e = (in & 0x7C00) >> 10;
    const unsigned short m = in & 0x3FF;
    const float sgn = (s ? -1.0f : 1.0f);
 
    if (e == 0)
    {
        if (m == 0) return sgn * 0.0f; /* +0.0 or -0.0 */
        else return sgn * powf(2, -14.0f) * (m / 1024.0f);
    }
    else
    {
        return sgn * powf(2, e - 15.0f) * (1.0f + (m / 1024.0f));
    }
}

Referenced by D3DXFloat16To32Array(), format_to_d3dx_color(), generic_float16_2(), generic_float16_4(), and wined3d_context_gl_load_numbered_arrays().

float_32_to_16()

unsigned short float_32_to_16

(

const float

in

)

Definition at line 2102 of file math.c.

{
    int exp = 0, origexp;
    float tmp = fabsf(in);
    int sign = (copysignf(1, in) < 0);
    unsigned int mantissa;
    unsigned short ret;
 
    /* Deal with special numbers */
    if (isinf(in)) return (sign ? 0xffff : 0x7fff);
    if (isnan(in)) return (sign ? 0xffff : 0x7fff);
    if (in == 0.0f) return (sign ? 0x8000 : 0x0000);
 
    if (tmp < (float)(1u << 10))
    {
        do
        {
            tmp *= 2.0f;
            exp--;
        } while (tmp < (float)(1u << 10));
    }
    else if (tmp >= (float)(1u << 11))
    {
        do
        {
            tmp /= 2.0f;
            exp++;
        } while (tmp >= (float)(1u << 11));
    }
 
    exp += 10;  /* Normalize the mantissa */
    exp += 15;  /* Exponent is encoded with excess 15 */
 
    origexp = exp;
 
    mantissa = (unsigned int) tmp;
    if ((tmp - mantissa == 0.5f && mantissa % 2 == 1) || /* round half to even */
        (tmp - mantissa > 0.5f))
    {
        mantissa++; /* round to nearest, away from zero */
    }
    if (mantissa == 2048)
    {
        mantissa = 1024;
        exp++;
    }
 
    if (exp > 31)
    {
        /* too big */
        ret = 0x7fff; /* INF */
    }
    else if (exp <= 0)
    {
        unsigned int rounding = 0;
 
        /* Denormalized half float */
 
        /* return 0x0000 (=0.0) for numbers too small to represent in half floats */
        if (exp < -11)
            return (sign ? 0x8000 : 0x0000);
 
        exp = origexp;
 
        /* the 13 extra bits from single precision are used for rounding */
        mantissa = (unsigned int)(tmp * (1u << 13));
        mantissa >>= 1 - exp; /* denormalize */
 
        mantissa -= ~(mantissa >> 13) & 1; /* round half to even */
        /* remove 13 least significant bits to get half float precision */
        mantissa >>= 12;
        rounding = mantissa & 1;
        mantissa >>= 1;
 
        ret = mantissa + rounding;
    }
    else
    {
        ret = (exp << 10) | (mantissa & 0x3ff);
    }
 
    ret |= ((sign ? 1 : 0) << 15); /* Add the sign */
    return ret;
}

Referenced by convert_r32_float_r16_float(), D3DXFloat32To16Array(), format_from_d3dx_color(), and wined3d_format_convert_from_float().

format_from_d3dx_color()

void format_from_d3dx_color	(	const struct pixel_format_desc *	format,
		const struct d3dx_color *	src,
		BYTE *	dst
	)

Definition at line 2051 of file surface.c.

{
    DWORD v, mask32;
    unsigned int c, i;
 
    memset(dst, 0, format->bytes_per_pixel);
 
    for (c = 0; c < 4; ++c)
    {
        const enum component_type dst_ctype = !c ? format->a_type : format->rgb_type;
        static const unsigned int component_offsets[4] = {3, 0, 1, 2};
        const float src_component = *(&src->value.x + component_offsets[c]);
        const enum range src_range = !c ? src->a_range : src->rgb_range;
 
        if (!format->bits[c])
            continue;
 
        mask32 = ~0u >> (32 - format->bits[c]);
 
        switch (dst_ctype)
        {
        case CTYPE_FLOAT:
            if (format->bits[c] == 16)
                v = float_32_to_16(src_component);
            else
                v = *(DWORD *)&src_component;
            break;
 
        case CTYPE_LUMA:
        {
            float val = src->value.x * 0.2125f + src->value.y * 0.7154f + src->value.z * 0.0721f;
 
            if (src_range == RANGE_SNORM)
                val = (val + 1.0f) / 2.0f;
 
            v = d3dx_clamp(val, 0.0f, 1.0f) * ((1u << format->bits[c]) - 1) + 0.5f;
            break;
        }
 
        case CTYPE_UNORM:
        {
            float val = src_component;
 
            if (src_range == RANGE_SNORM)
                val = (val + 1.0f) / 2.0f;
 
            v = d3dx_clamp(val, 0.0f, 1.0f) * ((1u << format->bits[c]) - 1) + 0.5f;
            break;
        }
 
        case CTYPE_SNORM:
        {
            const uint32_t max_value = (1u << (format->bits[c] - 1)) - 1;
            float val = src_component;
 
            if (src_range == RANGE_UNORM)
                val = (val * 2.0f) - 1.0f;
 
            v = d3dx_clamp(val, -1.0f, 1.0f) * max_value + 0.5f;
            break;
        }
 
        /* We shouldn't be trying to output to CTYPE_INDEX. */
        case CTYPE_INDEX:
            assert(0);
            break;
 
        default:
            v = 0;
            break;
        }
 
        for (i = format->shift[c] / 8 * 8; i < format->shift[c] + format->bits[c]; i += 8)
        {
            BYTE mask, byte;
 
            if (format->shift[c] > i)
            {
                mask = mask32 << (format->shift[c] - i);
                byte = (v << (format->shift[c] - i)) & mask;
            }
            else
            {
                mask = mask32 >> (i - format->shift[c]);
                byte = (v >> (i - format->shift[c])) & mask;
            }
            dst[i / 8] |= byte;
        }
    }
}

Referenced by convert_argb_pixels(), D3DXFillCubeTexture(), D3DXFillTexture(), D3DXFillVolumeTexture(), and point_filter_argb_pixels().

format_to_d3dx_color()

void format_to_d3dx_color	(	const struct pixel_format_desc *	format,
		const BYTE *	src,
		const PALETTEENTRY *	palette,
		struct d3dx_color *	dst
	)

Definition at line 1978 of file surface.c.

{
    DWORD mask, tmp;
    unsigned int c;
 
    dst->rgb_range = get_range_for_component_type(format->rgb_type);
    dst->a_range = get_range_for_component_type(format->a_type);
    for (c = 0; c < 4; ++c)
    {
        const enum component_type dst_ctype = !c ? format->a_type : format->rgb_type;
        static const unsigned int component_offsets[4] = {3, 0, 1, 2};
        float *dst_component = &dst->value.x + component_offsets[c];
 
        if (format->bits[c])
        {
            mask = ~0u >> (32 - format->bits[c]);
 
            memcpy(&tmp, src + format->shift[c] / 8,
                    min(sizeof(DWORD), (format->shift[c] % 8 + format->bits[c] + 7) / 8));
            tmp = (tmp >> (format->shift[c] % 8)) & mask;
 
            switch (dst_ctype)
            {
            case CTYPE_FLOAT:
                if (format->bits[c] == 16)
                    *dst_component = float_16_to_32(tmp);
                else
                    *dst_component = *(float *)&tmp;
                break;
 
            case CTYPE_INDEX:
                *dst_component = (&palette[tmp].peRed)[component_offsets[c]] / 255.0f;
                break;
 
            case CTYPE_LUMA:
            case CTYPE_UNORM:
                *dst_component = (float)tmp / mask;
                break;
 
            case CTYPE_SNORM:
            {
                const uint32_t sign_bit = (1u << (format->bits[c] - 1));
                uint32_t tmp_extended = (tmp & sign_bit) ? (tmp | ~(sign_bit - 1)) : tmp;
 
                /*
                 * In order to clamp to an even range, we need to ignore
                 * the maximum negative value.
                 */
                if (tmp == sign_bit)
                    tmp_extended |= 1;
 
                *dst_component = (float)(((int32_t)tmp_extended)) / (sign_bit - 1);
                break;
            }
 
            default:
                break;
            }
        }
        else if (dst_ctype == CTYPE_LUMA)
        {
            assert(format->bits[1]);
            *dst_component = dst->value.x;
        }
        else
        {
            *dst_component = 1.0f;
        }
    }
}

Referenced by convert_argb_pixels(), D3DXSHProjectCubeMap(), and point_filter_argb_pixels().

format_types_match()

static BOOL format_types_match ( const struct pixel_format_desc *  src, const struct pixel_format_desc *  dst  )

inlinestatic

Definition at line 259 of file d3dx9_private.h.

{
    if ((src->a_type && dst->a_type) && (src->a_type != dst->a_type))
        return FALSE;
 
    if ((src->rgb_type && dst->rgb_type) && (src->rgb_type != dst->rgb_type))
        return FALSE;
 
    if (src->flags != dst->flags)
        return FALSE;
 
    return (src->rgb_type == dst->rgb_type || src->a_type == dst->a_type);
}

Referenced by check_texture_requirements(), convert_argb_pixels(), and point_filter_argb_pixels().

get_aligned_rect()

void get_aligned_rect	(	uint32_t	left,
		uint32_t	top,
		uint32_t	right,
		uint32_t	bottom,
		uint32_t	width,
		uint32_t	height,
		const struct pixel_format_desc *	fmt_desc,
		RECT *	aligned_rect
	)

Definition at line 2654 of file surface.c.

{
    SetRect(aligned_rect, left, top, right, bottom);
    if (aligned_rect->left & (fmt_desc->block_width - 1))
        aligned_rect->left = aligned_rect->left & ~(fmt_desc->block_width - 1);
    if (aligned_rect->top & (fmt_desc->block_height - 1))
        aligned_rect->top = aligned_rect->top & ~(fmt_desc->block_height - 1);
    if (aligned_rect->right & (fmt_desc->block_width - 1) && aligned_rect->right != width)
        aligned_rect->right = min((aligned_rect->right + fmt_desc->block_width - 1)
                & ~(fmt_desc->block_width - 1), width);
    if (aligned_rect->bottom & (fmt_desc->block_height - 1) && aligned_rect->bottom != height)
        aligned_rect->bottom = min((aligned_rect->bottom + fmt_desc->block_height - 1)
                & ~(fmt_desc->block_height - 1), height);
}

Referenced by d3dx_load_surface_from_memory(), and d3dx_load_volume_from_memory().

get_bool()

static BOOL get_bool ( D3DXPARAMETER_TYPE  type, const void *  data  )

inlinestatic

Definition at line 337 of file d3dx9_private.h.

{
    switch (type)
    {
        case D3DXPT_FLOAT:
        case D3DXPT_INT:
        case D3DXPT_BOOL:
            return !!*(DWORD *)data;
 
        case D3DXPT_VOID:
            return *(BOOL *)data;
 
        default:
            return FALSE;
    }
}

Referenced by boolval_this(), debugstr_jsval(), equal_values(), get_float(), get_int(), interp_end_finally(), jsval_map_compare(), jsval_strict_equal(), jsval_to_variant(), set_number(), stringify(), to_boolean(), to_number(), to_object(), and to_string().

get_d3dx_pixel_format_info()

const struct pixel_format_desc * get_d3dx_pixel_format_info

(

enum d3dx_pixel_format_id

format

)

Definition at line 297 of file util.c.

{
    return &formats[min(format, D3DX_PIXEL_FORMAT_COUNT)];
}

Referenced by d3dformat_from_d3dx_pixel_format_id(), d3dx_calculate_pixels_size(), d3dx_image_tga_decode(), d3dx_image_wic_frame_decode(), d3dx_load_surface_from_memory(), d3dx_load_volume_from_memory(), d3dx_pixels_init(), d3dx_save_pixels_to_memory(), D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), and D3DXCreateVolumeTextureFromFileInMemoryEx().

get_float()

static float get_float ( D3DXPARAMETER_TYPE  type, const void *  data  )

inlinestatic

Definition at line 373 of file d3dx9_private.h.

{
    switch (type)
    {
        case D3DXPT_FLOAT:
        case D3DXPT_VOID:
            return *(float *)data;
 
        case D3DXPT_INT:
            return (float)(*(int *)data);
 
        case D3DXPT_BOOL:
            return (float)get_bool(type, data);
 
        default:
            return 0.0f;
    }
}

Referenced by set_number().

get_format_info()

const struct pixel_format_desc * get_format_info

(

D3DFORMAT

format

)

Definition at line 312 of file util.c.

{
    const struct pixel_format_desc *fmt_desc = &formats[d3dx_pixel_format_id_from_d3dformat(format)];
 
    if (is_unknown_format(fmt_desc))
        FIXME("Unknown format %s.\n", debugstr_fourcc(format));
    return fmt_desc;
}

Referenced by check_texture_requirements(), convert_argb_pixels(), d3dx_image_tga_decode(), d3dx_load_surface_from_memory(), d3dx_load_volume_from_memory(), d3dx_pixels_decompress(), D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), D3DXCreateVolumeTextureFromFileInMemoryEx(), D3DXFillCubeTexture(), D3DXFillTexture(), D3DXFillVolumeTexture(), D3DXLoadSurfaceFromMemory(), D3DXLoadSurfaceFromSurface(), D3DXLoadVolumeFromMemory(), D3DXSaveSurfaceToFileInMemory(), D3DXSHProjectCubeMap(), point_filter_argb_pixels(), and save_dds_surface_to_memory().

get_format_info_idx()

const struct pixel_format_desc * get_format_info_idx

(

int

idx

)

Definition at line 321 of file util.c.

{
    return idx < D3DX_PIXEL_FORMAT_COUNT ? &formats[idx] : NULL;
}

Referenced by check_texture_requirements().

get_int()

static int get_int ( D3DXPARAMETER_TYPE  type, const void *  data  )

inlinestatic

Definition at line 354 of file d3dx9_private.h.

{
    switch (type)
    {
        case D3DXPT_FLOAT:
            return (int)(*(float *)data);
 
        case D3DXPT_INT:
        case D3DXPT_VOID:
            return *(int *)data;
 
        case D3DXPT_BOOL:
            return get_bool(type, data);
 
        default:
            return 0;
    }
}

Referenced by arg_clbk_type(), create_positional_ctx(), and set_number().

get_parameter_by_name()

struct d3dx_parameter * get_parameter_by_name	(	struct d3dx_parameters_store *	store,
		struct d3dx_parameter *	parameter,
		const char *	name
	)

Definition at line 1041 of file effect.c.

{
    struct d3dx_parameter *temp_parameter;
    unsigned int name_len, param_name_len;
    unsigned int i, count, length;
    struct wine_rb_entry *entry;
    unsigned int full_name_size;
    const char *part;
    char *full_name;
 
    TRACE("store %p, parameter %p, name %s.\n", store, parameter, debugstr_a(name));
 
    if (!name || !*name) return NULL;
 
    if (!parameter)
    {
        if ((entry = wine_rb_get(&store->tree, name)))
            return WINE_RB_ENTRY_VALUE(entry, struct d3dx_parameter, rb_entry);
        return NULL;
    }
 
    if (parameter->full_name)
    {
        name_len = strlen(name);
        param_name_len = strlen(parameter->full_name);
        full_name_size = name_len + param_name_len + 2;
        if (store->full_name_tmp_size < full_name_size)
        {
            if (!(full_name = realloc(store->full_name_tmp, full_name_size)))
            {
                ERR("Out of memory.\n");
                return NULL;
            }
            store->full_name_tmp = full_name;
            store->full_name_tmp_size = full_name_size;
        }
        else
        {
            full_name = store->full_name_tmp;
        }
        memcpy(full_name, parameter->full_name, param_name_len);
        full_name[param_name_len] = '.';
        memcpy(full_name + param_name_len + 1, name, name_len);
        full_name[param_name_len + 1 + name_len] = 0;
 
        if ((entry = wine_rb_get(&store->tree, full_name)))
            return WINE_RB_ENTRY_VALUE(entry, struct d3dx_parameter, rb_entry);
        return NULL;
    }
 
    /* Pass / technique annotations are not stored in the parameters tree,
     * do a linear search. */
    count = parameter->member_count;
 
    length = strcspn( name, "[." );
    part = name + length;
 
    for (i = 0; i < count; i++)
    {
        temp_parameter = &parameter->members[i];
 
        if (!strcmp(temp_parameter->name, name))
        {
            TRACE("Returning parameter %p\n", temp_parameter);
            return temp_parameter;
        }
        else if (strlen(temp_parameter->name) == length && !strncmp(temp_parameter->name, name, length))
        {
            switch (*part++)
            {
                case '.':
                    return get_parameter_by_name(store, temp_parameter, part);
 
                case '[':
                    return get_parameter_element_by_name(store, temp_parameter, part);
 
                default:
                    FIXME("Unhandled case \"%c\"\n", *--part);
                    break;
            }
        }
    }
 
    TRACE("Parameter not found\n");
    return NULL;
}

Referenced by d3dx9_effect_init_from_binary(), d3dx_effect_GetParameterByName(), d3dx_parse_array_selector(), d3dx_parse_resource(), get_annotation_by_name(), get_constants_desc(), get_parameter_by_name(), get_parameter_element_by_name(), and get_valid_parameter().

is_compressed_format()

static BOOL is_compressed_format ( const struct pixel_format_desc *  format )

inlinestatic

Definition at line 249 of file d3dx9_private.h.

{
    return !!(format->flags & FMT_FLAG_DXT);
}

Referenced by d3dx_load_pixels_from_pixels(), d3dx_pixels_init(), D3DXFillCubeTexture(), D3DXFillTexture(), D3DXFillVolumeTexture(), and D3DXSHProjectCubeMap().

is_conversion_from_supported()

static BOOL is_conversion_from_supported ( const struct pixel_format_desc *  format )

inlinestatic

Definition at line 278 of file d3dx9_private.h.

{
    return !is_packed_format(format) && !is_unknown_format(format);
}

Referenced by d3dx_load_pixels_from_pixels(), and D3DXSaveSurfaceToFileInMemory().

is_conversion_to_supported()

static BOOL is_conversion_to_supported ( const struct pixel_format_desc *  format )

inlinestatic

Definition at line 283 of file d3dx9_private.h.

{
    return !is_index_format(format) && !is_packed_format(format) && !is_unknown_format(format);
}

Referenced by d3dx_load_pixels_from_pixels(), and D3DXSaveSurfaceToFileInMemory().

is_index_format()

static BOOL is_index_format ( const struct pixel_format_desc *  format )

inlinestatic

Definition at line 244 of file d3dx9_private.h.

{
    return (format->a_type == CTYPE_INDEX || format->rgb_type == CTYPE_INDEX);
}

Referenced by d3dx_image_wic_frame_decode(), d3dx_save_pixels_to_memory(), D3DXFillCubeTexture(), D3DXFillTexture(), D3DXFillVolumeTexture(), D3DXSaveSurfaceToFileInMemory(), D3DXSHProjectCubeMap(), is_conversion_to_supported(), and save_dds_surface_to_memory().

is_internal_format()

static BOOL is_internal_format ( const struct pixel_format_desc *  format )

inlinestatic

Definition at line 273 of file d3dx9_private.h.

{
    return !!(format->flags & FMT_FLAG_INTERNAL);
}

Referenced by d3dformat_from_d3dx_pixel_format_id().

is_packed_format()

static BOOL is_packed_format ( const struct pixel_format_desc *  format )

inlinestatic

Definition at line 254 of file d3dx9_private.h.

{
    return !!(format->flags & FMT_FLAG_PACKED);
}

Referenced by is_conversion_from_supported(), and is_conversion_to_supported().

is_param_dirty()

static BOOL is_param_dirty ( struct d3dx_parameter *  param, ULONG64  update_version  )

inlinestatic

Definition at line 581 of file d3dx9_private.h.

{
    return is_top_level_param_dirty(param->top_level_param, update_version);
}

Referenced by d3dx9_get_param_value_ptr(), and set_constants().

is_param_eval_input_dirty()

BOOL is_param_eval_input_dirty	(	struct d3dx_param_eval *	peval,
		ULONG64	update_version
	)

Definition at line 1716 of file preshader.c.

{
    return is_const_tab_input_dirty(&peval->pres.inputs, update_version)
            || is_const_tab_input_dirty(&peval->shader_inputs, update_version);
}

Referenced by d3dx9_get_param_value_ptr().

is_param_type_sampler()

static BOOL is_param_type_sampler ( D3DXPARAMETER_TYPE  type )

inlinestatic

Definition at line 420 of file d3dx9_private.h.

{
    return type == D3DXPT_SAMPLER
            || type == D3DXPT_SAMPLER1D || type == D3DXPT_SAMPLER2D
            || type == D3DXPT_SAMPLER3D || type == D3DXPT_SAMPLERCUBE;
}

Referenced by d3dx_effect_GetValue(), d3dx_effect_SetValue(), d3dx_pool_sync_shared_parameter(), d3dx_set_shader_constants(), free_parameter_data(), get_constants_desc(), walk_parameter_dep(), and walk_state_dep().

is_top_level_param_dirty()

static BOOL is_top_level_param_dirty ( struct d3dx_top_level_parameter *  param, ULONG64  update_version  )

inlinestatic

Definition at line 571 of file d3dx9_private.h.

{
    struct d3dx_shared_data *shared_data;
 
    if ((shared_data = param->shared_data))
        return update_version < shared_data->update_version;
    else
        return update_version < param->update_version;
}

Referenced by is_const_tab_input_dirty(), and is_param_dirty().

is_top_level_parameter()

static BOOL is_top_level_parameter ( struct d3dx_parameter *  param )

inlinestatic

Definition at line 555 of file d3dx9_private.h.

{
    return &param->top_level_param->param == param;
}

Referenced by add_param_to_tree(), d3dx_effect_GetParameterDesc(), get_annotation_from_object(), and get_constants_desc().

is_unknown_format()

static BOOL is_unknown_format ( const struct pixel_format_desc *  format )

inlinestatic

Definition at line 239 of file d3dx9_private.h.

{
    return (format->format == D3DX_PIXEL_FORMAT_COUNT);
}

Referenced by d3dx_calculate_pixels_size(), d3dx_load_volume_from_memory(), d3dx_pixels_init(), D3DXFillCubeTexture(), D3DXFillTexture(), D3DXFillVolumeTexture(), D3DXLoadSurfaceFromMemory(), D3DXLoadVolumeFromMemory(), D3DXSHProjectCubeMap(), get_format_info(), is_conversion_from_supported(), is_conversion_to_supported(), and save_dds_surface_to_memory().

load_resource_into_memory()

HRESULT load_resource_into_memory	(	HMODULE	module,
		HRSRC	resinfo,
		void **	buffer,
		DWORD *	length
	)

Definition at line 261 of file util.c.

{
    HGLOBAL resource;
 
    *length = SizeofResource(module, resinfo);
    if(*length == 0) return HRESULT_FROM_WIN32(GetLastError());
 
    resource = LoadResource(module, resinfo);
    if( !resource ) return HRESULT_FROM_WIN32(GetLastError());
 
    *buffer = LockResource(resource);
    if(*buffer == NULL) return HRESULT_FROM_WIN32(GetLastError());
 
    return S_OK;
}

Referenced by D3DXAssembleShaderFromResourceA(), D3DXAssembleShaderFromResourceW(), D3DXCompileShaderFromResourceA(), D3DXCompileShaderFromResourceW(), D3DXCreateEffectCompilerFromResourceA(), D3DXCreateEffectCompilerFromResourceW(), D3DXCreateEffectFromResourceExA(), D3DXCreateEffectFromResourceExW(), D3DXCreateTextureFromResourceExA(), D3DXCreateTextureFromResourceExW(), D3DXGetImageInfoFromResourceA(), D3DXGetImageInfoFromResourceW(), D3DXLoadMeshFromXResource(), D3DXLoadSurfaceFromResourceA(), D3DXLoadSurfaceFromResourceW(), D3DXPreprocessShaderFromResourceA(), and D3DXPreprocessShaderFromResourceW().

lock_surface()

HRESULT lock_surface	(	IDirect3DSurface9 *	surface,
		const RECT *	surface_rect,
		D3DLOCKED_RECT *	lock,
		IDirect3DSurface9 **	temp_surface,
		BOOL	write
	)

Definition at line 156 of file surface.c.

{
    unsigned int width, height;
    IDirect3DDevice9 *device;
    D3DSURFACE_DESC desc;
    DWORD lock_flag;
    HRESULT hr;
 
    lock_flag = write ? 0 : D3DLOCK_READONLY;
    *temp_surface = NULL;
    if (FAILED(hr = IDirect3DSurface9_LockRect(surface, lock, surface_rect, lock_flag)))
    {
        IDirect3DSurface9_GetDevice(surface, &device);
        IDirect3DSurface9_GetDesc(surface, &desc);
 
        if (surface_rect)
        {
            width = surface_rect->right - surface_rect->left;
            height = surface_rect->bottom - surface_rect->top;
        }
        else
        {
            width = desc.Width;
            height = desc.Height;
        }
 
        hr = write ? IDirect3DDevice9_CreateOffscreenPlainSurface(device, width, height,
                desc.Format, D3DPOOL_SYSTEMMEM, temp_surface, NULL)
                : IDirect3DDevice9_CreateRenderTarget(device, width, height,
                desc.Format, D3DMULTISAMPLE_NONE, 0, TRUE, temp_surface, NULL);
        if (FAILED(hr))
        {
            WARN("Failed to create temporary surface, surface %p, format %#x, "
                    "usage %#lx, pool %#x, write %#x, width %u, height %u.\n",
                    surface, desc.Format, desc.Usage, desc.Pool, write, width, height);
            IDirect3DDevice9_Release(device);
            return hr;
        }
 
        if (write || SUCCEEDED(hr = IDirect3DDevice9_StretchRect(device, surface, surface_rect,
                *temp_surface, NULL, D3DTEXF_NONE)))
            hr = IDirect3DSurface9_LockRect(*temp_surface, lock, NULL, lock_flag);
 
        IDirect3DDevice9_Release(device);
        if (FAILED(hr))
        {
            WARN("Failed to lock surface %p, write %#x, usage %#lx, pool %#x.\n",
                    surface, write, desc.Usage, desc.Pool);
            IDirect3DSurface9_Release(*temp_surface);
            *temp_surface = NULL;
            return hr;
        }
        TRACE("Created temporary surface %p.\n", surface);
    }
    return hr;
}

Referenced by d3dx_load_surface_from_memory(), D3DXFillTexture(), D3DXLoadSurfaceFromSurface(), D3DXSaveSurfaceToFileInMemory(), and save_dds_surface_to_memory().

make_pow2()

static uint32_t make_pow2 ( uint32_t  num )

inlinestatic

Definition at line 428 of file d3dx9_private.h.

{
    DWORD index;
 
    return BitScanReverse(&index, num - 1) ? 1u << (index + 1) : 1;
}

Referenced by check_texture_requirements(), D3DXCheckCubeTextureRequirements(), D3DXCheckVolumeTextureRequirements(), D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateFontIndirectW(), D3DXCreateTextureFromFileInMemoryEx(), and D3DXCreateVolumeTextureFromFileInMemoryEx().

map_view_of_file()

HRESULT map_view_of_file	(	const WCHAR *	filename,
		void **	buffer,
		DWORD *	length
	)

Definition at line 211 of file util.c.

{
    HANDLE hfile, hmapping = NULL;
 
    hfile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
    if(hfile == INVALID_HANDLE_VALUE) goto error;
 
    *length = GetFileSize(hfile, NULL);
    if(*length == INVALID_FILE_SIZE) goto error;
 
    hmapping = CreateFileMappingW(hfile, NULL, PAGE_READONLY, 0, 0, NULL);
    if(!hmapping) goto error;
 
    *buffer = MapViewOfFile(hmapping, FILE_MAP_READ, 0, 0, 0);
    if(*buffer == NULL) goto error;
 
    CloseHandle(hmapping);
    CloseHandle(hfile);
 
    return S_OK;
 
error:
    if (hmapping)
        CloseHandle(hmapping);
    if (hfile != INVALID_HANDLE_VALUE)
        CloseHandle(hfile);
    return HRESULT_FROM_WIN32(GetLastError());
}

Referenced by D3DXCreateCubeTextureFromFileA(), D3DXCreateCubeTextureFromFileExA(), D3DXCreateCubeTextureFromFileExW(), D3DXCreateCubeTextureFromFileW(), D3DXCreateEffectCompilerFromFileW(), D3DXCreateTextureFromFileExW(), D3DXCreateVolumeTextureFromFileA(), D3DXCreateVolumeTextureFromFileExA(), D3DXCreateVolumeTextureFromFileExW(), D3DXCreateVolumeTextureFromFileW(), D3DXGetImageInfoFromFileW(), D3DXLoadMeshFromXW(), D3DXLoadMeshHierarchyFromXW(), D3DXLoadSurfaceFromFileW(), and D3DXLoadVolumeFromFileW().

next_update_version()

static ULONG64 next_update_version ( ULONG64 *  version_counter )

inlinestatic

Definition at line 566 of file d3dx9_private.h.

{
    return ++*version_counter;
}

Referenced by d3dx_evaluate_parameter(), d3dx_param_eval_set_shader_constants(), next_effect_update_version(), and set_dirty().

point_filter_argb_pixels()

void point_filter_argb_pixels	(	const BYTE *	src,
		UINT	src_row_pitch,
		UINT	src_slice_pitch,
		const struct volume *	src_size,
		const struct pixel_format_desc *	src_format,
		BYTE *	dst,
		UINT	dst_row_pitch,
		UINT	dst_slice_pitch,
		const struct volume *	dst_size,
		const struct pixel_format_desc *	dst_format,
		D3DCOLOR	color_key,
		const PALETTEENTRY *	palette
	)

Definition at line 2280 of file surface.c.

{
    struct argb_conversion_info conv_info, ck_conv_info;
    const struct pixel_format_desc *ck_format;
    DWORD channels[4];
    UINT x, y, z;
 
    TRACE("src %p, src_row_pitch %u, src_slice_pitch %u, src_size %p, src_format %p, dst %p, "
            "dst_row_pitch %u, dst_slice_pitch %u, dst_size %p, dst_format %p, color_key 0x%08lx, palette %p.\n",
            src, src_row_pitch, src_slice_pitch, src_size, src_format, dst, dst_row_pitch, dst_slice_pitch, dst_size,
            dst_format, color_key, palette);
 
    ZeroMemory(channels, sizeof(channels));
    init_argb_conversion_info(src_format, dst_format, &conv_info);
 
    if (color_key)
    {
        /* Color keys are always represented in D3DFMT_A8R8G8B8 format. */
        ck_format = get_format_info(D3DFMT_A8R8G8B8);
        init_argb_conversion_info(src_format, ck_format, &ck_conv_info);
    }
 
    for (z = 0; z < dst_size->depth; z++)
    {
        BYTE *dst_slice_ptr = dst + z * dst_slice_pitch;
        const BYTE *src_slice_ptr = src + src_slice_pitch * (z * src_size->depth / dst_size->depth);
 
        for (y = 0; y < dst_size->height; y++)
        {
            BYTE *dst_ptr = dst_slice_ptr + y * dst_row_pitch;
            const BYTE *src_row_ptr = src_slice_ptr + src_row_pitch * (y * src_size->height / dst_size->height);
 
            for (x = 0; x < dst_size->width; x++)
            {
                const BYTE *src_ptr = src_row_ptr + (x * src_size->width / dst_size->width) * src_format->bytes_per_pixel;
 
                if (format_types_match(src_format, dst_format)
                        && src_format->bytes_per_pixel <= 4 && dst_format->bytes_per_pixel <= 4)
                {
                    DWORD val;
 
                    get_relevant_argb_components(&conv_info, src_ptr, channels);
                    val = make_argb_color(&conv_info, channels);
 
                    if (color_key)
                    {
                        DWORD ck_pixel;
 
                        get_relevant_argb_components(&ck_conv_info, src_ptr, channels);
                        ck_pixel = make_argb_color(&ck_conv_info, channels);
                        if (ck_pixel == color_key)
                            val &= ~conv_info.destmask[0];
                    }
                    memcpy(dst_ptr, &val, dst_format->bytes_per_pixel);
                }
                else
                {
                    struct d3dx_color color, tmp;
 
                    format_to_d3dx_color(src_format, src_ptr, palette, &color);
                    tmp = color;
 
                    if (color_key)
                    {
                        DWORD ck_pixel;
 
                        format_from_d3dx_color(ck_format, &tmp, (BYTE *)&ck_pixel);
                        if (ck_pixel == color_key)
                            tmp.value.w = 0.0f;
                    }
 
                    color = tmp;
                    format_from_d3dx_color(dst_format, &color, dst_ptr);
                }
 
                dst_ptr += dst_format->bytes_per_pixel;
            }
        }
    }
}

Referenced by d3dx_load_pixels_from_pixels().

set_d3dx_color()

static void set_d3dx_color ( struct d3dx_color *  color, const struct vec4 *  value, enum range  rgb_range, enum range  a_range  )

inlinestatic

Definition at line 71 of file d3dx9_private.h.

{
    color->value = *value;
    color->rgb_range = rgb_range;
    color->a_range = a_range;
}

Referenced by D3DXFillCubeTexture(), D3DXFillTexture(), and D3DXFillVolumeTexture().

set_d3dx_pixels()

static void set_d3dx_pixels ( struct d3dx_pixels *  pixels, const void *  data, uint32_t  row_pitch, uint32_t  slice_pitch, const PALETTEENTRY *  palette, uint32_t  width, uint32_t  height, uint32_t  depth, const RECT *  unaligned_rect  )

inlinestatic

Definition at line 187 of file d3dx9_private.h.

{
    pixels->data = data;
    pixels->row_pitch = row_pitch;
    pixels->slice_pitch = slice_pitch;
    pixels->palette = palette;
    set_volume_struct(&pixels->size, width, height, depth);
    pixels->unaligned_rect = *unaligned_rect;
}

Referenced by d3dx_image_get_pixels(), d3dx_load_surface_from_memory(), d3dx_load_volume_from_memory(), d3dx_pixels_init(), d3dx_save_pixels_to_memory(), D3DXCreateCubeTextureFromFileInMemoryEx(), D3DXCreateTextureFromFileInMemoryEx(), and D3DXCreateVolumeTextureFromFileInMemoryEx().

set_number()

static void set_number ( void *  outdata, D3DXPARAMETER_TYPE  outtype, const void *  indata, D3DXPARAMETER_TYPE  intype  )

inlinestatic

Definition at line 392 of file d3dx9_private.h.

{
    if (outtype == intype)
    {
        *(DWORD *)outdata = *(DWORD *)indata;
        return;
    }
 
    switch (outtype)
    {
        case D3DXPT_FLOAT:
            *(float *)outdata = get_float(intype, indata);
            break;
 
        case D3DXPT_BOOL:
            *(BOOL *)outdata = get_bool(intype, indata);
            break;
 
        case D3DXPT_INT:
            *(int *)outdata = get_int(intype, indata);
            break;
 
        default:
            *(DWORD *)outdata = 0;
            break;
    }
}

Referenced by d3dx_effect_GetBool(), d3dx_effect_GetBoolArray(), d3dx_effect_GetFloat(), d3dx_effect_GetFloatArray(), d3dx_effect_GetInt(), d3dx_effect_GetIntArray(), d3dx_effect_SetBool(), d3dx_effect_SetBoolArray(), d3dx_effect_SetFloat(), d3dx_effect_SetFloatArray(), d3dx_effect_SetInt(), d3dx_effect_SetIntArray(), d3dx_evaluate_parameter(), get_matrix(), get_vector(), set(), set_matrix(), set_matrix_transpose(), set_vector(), and test_effect_parameter_value().

set_volume_struct()

static void set_volume_struct ( struct volume *  volume, uint32_t  width, uint32_t  height, uint32_t  depth  )

inlinestatic

Definition at line 86 of file d3dx9_private.h.

{
    volume->width = width;
    volume->height = height;
    volume->depth = depth;
}

Referenced by d3dx_initialize_image_from_dds(), d3dx_initialize_image_from_tga(), d3dx_load_pixels_from_pixels(), and set_d3dx_pixels().

top_level_parameter_from_parameter()

static struct d3dx_top_level_parameter * top_level_parameter_from_parameter ( struct d3dx_parameter *  param )

inlinestatic

Definition at line 561 of file d3dx9_private.h.

{
    return CONTAINING_RECORD(param, struct d3dx_top_level_parameter, param);
}

Referenced by d3dx_effect_GetParameterDesc(), get_annotation_from_object(), and is_const_tab_input_dirty().

unlock_surface()

HRESULT unlock_surface	(	IDirect3DSurface9 *	surface,
		const RECT *	surface_rect,
		IDirect3DSurface9 *	temp_surface,
		BOOL	update
	)

Definition at line 214 of file surface.c.

{
    IDirect3DDevice9 *device;
    POINT surface_point;
    HRESULT hr;
 
    if (!temp_surface)
    {
        hr = IDirect3DSurface9_UnlockRect(surface);
        return hr;
    }
 
    hr = IDirect3DSurface9_UnlockRect(temp_surface);
    if (update)
    {
        if (surface_rect)
        {
            surface_point.x = surface_rect->left;
            surface_point.y = surface_rect->top;
        }
        else
        {
            surface_point.x = 0;
            surface_point.y = 0;
        }
        IDirect3DSurface9_GetDevice(surface, &device);
        if (FAILED(hr = IDirect3DDevice9_UpdateSurface(device, temp_surface, NULL, surface, &surface_point)))
            WARN("Updating surface failed, hr %#lx, surface %p, temp_surface %p.\n",
                    hr, surface, temp_surface);
        IDirect3DDevice9_Release(device);
    }
    IDirect3DSurface9_Release(temp_surface);
    return hr;
}

Referenced by d3dx_load_surface_from_memory(), D3DXFillTexture(), D3DXLoadSurfaceFromSurface(), D3DXSaveSurfaceToFileInMemory(), and save_dds_surface_to_memory().

write_buffer_to_file()

HRESULT write_buffer_to_file	(	const WCHAR *	filename,
		ID3DXBuffer *	buffer
	)

Definition at line 277 of file util.c.

{
    HRESULT hr = S_OK;
    void *buffer_pointer;
    DWORD buffer_size;
    DWORD bytes_written;
    HANDLE file = CreateFileW(dst_filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (file == INVALID_HANDLE_VALUE)
        return HRESULT_FROM_WIN32(GetLastError());
 
    buffer_pointer = ID3DXBuffer_GetBufferPointer(buffer);
    buffer_size = ID3DXBuffer_GetBufferSize(buffer);
 
    if (!WriteFile(file, buffer_pointer, buffer_size, &bytes_written, NULL))
        hr = HRESULT_FROM_WIN32(GetLastError());
 
    CloseHandle(file);
    return hr;
}

Referenced by D3DXSaveSurfaceToFileA(), D3DXSaveSurfaceToFileW(), D3DXSaveTextureToFileA(), and D3DXSaveTextureToFileW().

Variable Documentation

d3dx_include_from_file_vtbl

const struct ID3DXIncludeVtbl d3dx_include_from_file_vtbl

extern

Definition at line 328 of file shader.c.

Referenced by D3DXAssembleShaderFromFileW(), D3DXCompileShaderFromFileW(), D3DXCreateEffectFromFileExW(), and D3DXPreprocessShaderFromFileW().

from_file_mutex

CRITICAL_SECTION from_file_mutex

extern

Definition at line 242 of file shader.c.

Referenced by D3DXAssembleShaderFromFileW(), D3DXCompileShaderFromFileW(), D3DXCreateEffectFromFileExW(), and D3DXPreprocessShaderFromFileW().