d3dx9_private.h 12.5 KB
Newer Older
1
/*
2
 * Copyright (C) 2002 Raphael Junqueira
3
 * Copyright (C) 2008 David Adam
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 * Copyright (C) 2008 Tony Wasserka
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 *
 */

22 23
#ifndef __WINE_D3DX9_PRIVATE_H
#define __WINE_D3DX9_PRIVATE_H
24

25
#include <stdint.h>
26
#include "wine/debug.h"
27 28
#include "wine/heap.h"
#include "wine/rbtree.h"
29 30 31 32

#define COBJMACROS
#include "d3dx9.h"

33 34
#define ULONG64_MAX (~(ULONG64)0)

35 36 37 38 39
struct vec4
{
    float x, y, z, w;
};

40 41 42 43 44 45 46
struct volume
{
    UINT width;
    UINT height;
    UINT depth;
};

47
/* for internal use */
48
enum format_type {
49
    FORMAT_ARGB,   /* unsigned */
50
    FORMAT_ARGBF16,/* float 16 */
51
    FORMAT_ARGBF,  /* float */
52
    FORMAT_DXT,
53
    FORMAT_INDEX,
54
    FORMAT_UNKNOWN
55
};
56

57
struct pixel_format_desc {
58 59 60 61
    D3DFORMAT format;
    BYTE bits[4];
    BYTE shift[4];
    UINT bytes_per_pixel;
62 63 64
    UINT block_width;
    UINT block_height;
    UINT block_byte_count;
65
    enum format_type type;
66
    void (*from_rgba)(const struct vec4 *src, struct vec4 *dst);
67
    void (*to_rgba)(const struct vec4 *src, struct vec4 *dst, const PALETTEENTRY *palette);
68
};
69

70 71 72 73 74 75 76 77
struct d3dx_include_from_file
{
    ID3DXInclude ID3DXInclude_iface;
};

extern CRITICAL_SECTION from_file_mutex DECLSPEC_HIDDEN;
extern const struct ID3DXIncludeVtbl d3dx_include_from_file_vtbl DECLSPEC_HIDDEN;

78 79 80
static inline BOOL is_conversion_from_supported(const struct pixel_format_desc *format)
{
    if (format->type == FORMAT_ARGB || format->type == FORMAT_ARGBF16
81
            || format->type == FORMAT_ARGBF || format->type == FORMAT_DXT)
82 83 84 85 86 87 88
        return TRUE;
    return !!format->to_rgba;
}

static inline BOOL is_conversion_to_supported(const struct pixel_format_desc *format)
{
    if (format->type == FORMAT_ARGB || format->type == FORMAT_ARGBF16
89
            || format->type == FORMAT_ARGBF || format->type == FORMAT_DXT)
90 91 92 93
        return TRUE;
    return !!format->from_rgba;
}

Henri Verbeet's avatar
Henri Verbeet committed
94
HRESULT map_view_of_file(const WCHAR *filename, void **buffer, DWORD *length) DECLSPEC_HIDDEN;
Henri Verbeet's avatar
Henri Verbeet committed
95
HRESULT load_resource_into_memory(HMODULE module, HRSRC resinfo, void **buffer, DWORD *length) DECLSPEC_HIDDEN;
96

97 98
HRESULT write_buffer_to_file(const WCHAR *filename, ID3DXBuffer *buffer) DECLSPEC_HIDDEN;

99 100
const struct pixel_format_desc *get_format_info(D3DFORMAT format) DECLSPEC_HIDDEN;
const struct pixel_format_desc *get_format_info_idx(int idx) DECLSPEC_HIDDEN;
101

102 103
void format_to_vec4(const struct pixel_format_desc *format, const BYTE *src, struct vec4 *dst);

104 105 106
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) DECLSPEC_HIDDEN;
107 108 109
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,
110
    const struct pixel_format_desc *dst_format, D3DCOLOR color_key, const PALETTEENTRY *palette) DECLSPEC_HIDDEN;
111 112 113
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,
114
    const struct pixel_format_desc *dst_format, D3DCOLOR color_key, const PALETTEENTRY *palette) DECLSPEC_HIDDEN;
115

116
HRESULT load_texture_from_dds(IDirect3DTexture9 *texture, const void *src_data, const PALETTEENTRY *palette,
117
        DWORD filter, D3DCOLOR color_key, const D3DXIMAGE_INFO *src_info, unsigned int skip_levels,
118
        unsigned int *loaded_miplevels) DECLSPEC_HIDDEN;
119 120
HRESULT load_cube_texture_from_dds(IDirect3DCubeTexture9 *cube_texture, const void *src_data,
    const PALETTEENTRY *palette, DWORD filter, D3DCOLOR color_key, const D3DXIMAGE_INFO *src_info) DECLSPEC_HIDDEN;
121 122 123
HRESULT load_volume_from_dds(IDirect3DVolume9 *dst_volume, const PALETTEENTRY *dst_palette,
    const D3DBOX *dst_box, const void *src_data, const D3DBOX *src_box, DWORD filter, D3DCOLOR color_key,
    const D3DXIMAGE_INFO *src_info) DECLSPEC_HIDDEN;
124 125
HRESULT load_volume_texture_from_dds(IDirect3DVolumeTexture9 *volume_texture, const void *src_data,
    const PALETTEENTRY *palette, DWORD filter, DWORD color_key, const D3DXIMAGE_INFO *src_info) DECLSPEC_HIDDEN;
126
HRESULT lock_surface(IDirect3DSurface9 *surface, const RECT *surface_rect, D3DLOCKED_RECT *lock,
127
        IDirect3DSurface9 **temp_surface, BOOL write) DECLSPEC_HIDDEN;
128
HRESULT unlock_surface(IDirect3DSurface9 *surface, const RECT *surface_rect,
129
        IDirect3DSurface9 *temp_surface, BOOL update) DECLSPEC_HIDDEN;
130

131
unsigned short float_32_to_16(const float in) DECLSPEC_HIDDEN;
132
float float_16_to_32(const unsigned short in) DECLSPEC_HIDDEN;
133

134
/* debug helpers */
135 136
const char *debug_d3dxparameter_class(D3DXPARAMETER_CLASS c) DECLSPEC_HIDDEN;
const char *debug_d3dxparameter_type(D3DXPARAMETER_TYPE t) DECLSPEC_HIDDEN;
137
const char *debug_d3dxparameter_registerset(D3DXREGISTER_SET r) DECLSPEC_HIDDEN;
138

139
/* parameter type conversion helpers */
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
static inline BOOL get_bool(D3DXPARAMETER_TYPE type, const void *data)
{
    switch (type)
    {
        case D3DXPT_FLOAT:
        case D3DXPT_INT:
        case D3DXPT_BOOL:
            return !!*(DWORD *)data;

        case D3DXPT_VOID:
            return *(BOOL *)data;

        default:
            return FALSE;
    }
}

static inline int get_int(D3DXPARAMETER_TYPE type, const void *data)
{
    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;
    }
}

static inline float get_float(D3DXPARAMETER_TYPE type, const void *data)
{
    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;
    }
}

static inline void set_number(void *outdata, D3DXPARAMETER_TYPE outtype, const void *indata, D3DXPARAMETER_TYPE intype)
{
    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;
    }
}
222

223 224 225 226 227 228 229
static inline BOOL is_param_type_sampler(D3DXPARAMETER_TYPE type)
{
    return type == D3DXPT_SAMPLER
            || type == D3DXPT_SAMPLER1D || type == D3DXPT_SAMPLER2D
            || type == D3DXPT_SAMPLER3D || type == D3DXPT_SAMPLERCUBE;
}

230 231 232
/* Returns the smallest power of 2 which is greater than or equal to num */
static inline uint32_t make_pow2(uint32_t num)
{
233 234
    uint32_t index;
    return BitScanReverse(&index, num - 1) ? 1u << (index + 1) : 1;
235 236
}

237 238 239 240 241 242 243 244 245 246 247 248 249 250
struct d3dx_parameter;

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

251 252 253
struct d3dx_const_param_eval_output
{
    struct d3dx_parameter *param;
254
    enum pres_reg_tables table;
255 256 257
    enum D3DXPARAMETER_CLASS constant_class;
    unsigned int register_index;
    unsigned int register_count;
258
    BOOL direct_copy;
259
    unsigned int element_count;
260 261
};

262 263 264 265 266
struct d3dx_const_tab
{
    unsigned int input_count;
    D3DXCONSTANT_DESC *inputs;
    struct d3dx_parameter **inputs_param;
267 268 269
    unsigned int const_set_count;
    unsigned int const_set_size;
    struct d3dx_const_param_eval_output *const_set;
270
    const enum pres_reg_tables *regset2table;
271
    ULONG64 update_version;
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
};

struct d3dx_regstore
{
    void *tables[PRES_REGTAB_COUNT];
    unsigned int table_sizes[PRES_REGTAB_COUNT]; /* registers count */
};

struct d3dx_pres_ins;

struct d3dx_preshader
{
    struct d3dx_regstore regs;

    unsigned int ins_count;
    struct d3dx_pres_ins *ins;

    struct d3dx_const_tab inputs;
};

struct d3dx_param_eval
{
    D3DXPARAMETER_TYPE param_type;

    struct d3dx_preshader pres;
    struct d3dx_const_tab shader_inputs;
298

299 300
    ULONG64 *version_counter;
};
301

302 303 304 305 306 307 308
struct param_rb_entry
{
    struct wine_rb_entry entry;
    char *full_name;
    struct d3dx_parameter *param;
};

309
struct d3dx_shared_data;
310
struct d3dx_top_level_parameter;
311

312 313
struct d3dx_parameter
{
314
    char magic_string[4];
315 316
    struct d3dx_top_level_parameter *top_level_param;
    struct d3dx_param_eval *param_eval;
317 318 319 320 321 322 323 324 325 326 327 328 329
    char *name;
    void *data;
    D3DXPARAMETER_CLASS class;
    D3DXPARAMETER_TYPE  type;
    UINT rows;
    UINT columns;
    UINT element_count;
    UINT member_count;
    DWORD flags;
    UINT bytes;
    DWORD object_id;

    struct d3dx_parameter *members;
330
    char *semantic;
331 332 333

    char *full_name;
    struct wine_rb_entry rb_entry;
334
};
335

336 337 338 339 340 341 342
struct d3dx_top_level_parameter
{
    struct d3dx_parameter param;
    UINT annotation_count;
    struct d3dx_parameter *annotations;
    ULONG64 update_version;
    ULONG64 *version_counter;
343
    struct d3dx_shared_data *shared_data;
344 345
};

346
struct d3dx_shared_data
347
{
348
    void *data;
349
    struct d3dx_top_level_parameter **parameters;
350 351 352
    unsigned int size, count;
    ULONG64 update_version;
};
353

354
struct d3dx_effect;
355

356 357 358 359 360 361 362 363 364 365 366
static inline BOOL is_top_level_parameter(struct d3dx_parameter *param)
{
    return &param->top_level_param->param == param;
}

static inline struct d3dx_top_level_parameter
        *top_level_parameter_from_parameter(struct d3dx_parameter *param)
{
    return CONTAINING_RECORD(param, struct d3dx_top_level_parameter, param);
}

367 368 369 370 371
static inline ULONG64 next_update_version(ULONG64 *version_counter)
{
    return ++*version_counter;
}

372
static inline BOOL is_top_level_param_dirty(struct d3dx_top_level_parameter *param, ULONG64 update_version)
373 374 375
{
    struct d3dx_shared_data *shared_data;

376
    if ((shared_data = param->shared_data))
377 378
        return update_version < shared_data->update_version;
    else
379 380 381 382 383 384
        return update_version < param->update_version;
}

static inline BOOL is_param_dirty(struct d3dx_parameter *param, ULONG64 update_version)
{
    return is_top_level_param_dirty(param->top_level_param, update_version);
385 386
}

387
struct d3dx_parameter *get_parameter_by_name(struct d3dx_effect *effect,
388 389
        struct d3dx_parameter *parameter, const char *name) DECLSPEC_HIDDEN;

390 391 392 393
#define SET_D3D_STATE_(manager, device, method, args...) (manager ? manager->lpVtbl->method(manager, args) \
        : device->lpVtbl->method(device, args))
#define SET_D3D_STATE(base_effect, args...) SET_D3D_STATE_(base_effect->manager, base_effect->device, args)

394
HRESULT d3dx_create_param_eval(struct d3dx_effect *effect, void *byte_code,
395
        unsigned int byte_code_size, D3DXPARAMETER_TYPE type,
396 397
        struct d3dx_param_eval **peval, ULONG64 *version_counter,
        const char **skip_constants, unsigned int skip_constants_count) DECLSPEC_HIDDEN;
398
void d3dx_free_param_eval(struct d3dx_param_eval *peval) DECLSPEC_HIDDEN;
399
HRESULT d3dx_evaluate_parameter(struct d3dx_param_eval *peval,
400
        const struct d3dx_parameter *param, void *param_value) DECLSPEC_HIDDEN;
401
HRESULT d3dx_param_eval_set_shader_constants(ID3DXEffectStateManager *manager, struct IDirect3DDevice9 *device,
402
        struct d3dx_param_eval *peval, BOOL update_all) DECLSPEC_HIDDEN;
403
BOOL is_param_eval_input_dirty(struct d3dx_param_eval *peval, ULONG64 update_version) DECLSPEC_HIDDEN;
404

405 406
struct ctab_constant {
    D3DXCONSTANT_DESC desc;
407
    WORD constantinfo_reserved;
408 409 410 411 412 413
    struct ctab_constant *constants;
};

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

414
#endif /* __WINE_D3DX9_PRIVATE_H */