2
* Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
4
* Permission is hereby granted, free of charge, to any person obtaining a
5
* copy of this software and associated documentation files (the "Software"),
6
* to deal in the Software without restriction, including without limitation
7
* on the rights to use, copy, modify, merge, publish, distribute, sub
8
* license, and/or sell copies of the Software, and to permit persons to whom
9
* the Software is furnished to do so, subject to the following conditions:
11
* The above copyright notice and this permission notice (including the next
12
* paragraph) shall be included in all copies or substantial portions of the
15
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
18
* THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
19
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21
* USE OR OTHER DEALINGS IN THE SOFTWARE. */
27
#include "pipe/p_format.h"
28
#include "pipe/p_screen.h"
29
#include "pipe/p_state.h" /* pipe_box */
30
#include "util/macros.h"
31
#include "util/u_rect.h"
32
#include "util/format/u_format.h"
33
#include "nine_helpers.h"
37
extern const enum pipe_format nine_d3d9_to_pipe_format_map[120];
38
extern const D3DFORMAT nine_pipe_to_d3d9_format_map[PIPE_FORMAT_COUNT];
40
void nine_convert_dsa_state(struct pipe_depth_stencil_alpha_state *, const DWORD *);
41
void nine_convert_rasterizer_state(struct NineDevice9 *, struct pipe_rasterizer_state *, const DWORD *);
42
void nine_convert_blend_state(struct pipe_blend_state *, const DWORD *);
43
void nine_convert_sampler_state(struct cso_context *, int idx, const DWORD *);
45
#define is_ATI1_ATI2(format) (format == PIPE_FORMAT_RGTC1_UNORM || format == PIPE_FORMAT_RGTC2_UNORM)
48
rect_to_pipe_box(struct pipe_box *dst, const RECT *src)
53
dst->width = src->right - src->left;
54
dst->height = src->bottom - src->top;
59
pipe_box_to_rect(RECT *dst, const struct pipe_box *src)
62
dst->right = src->x + src->width;
64
dst->bottom = src->y + src->height;
68
rect_minify_inclusive(RECT *rect)
70
rect->left = rect->left >> 2;
71
rect->top = rect->top >> 2;
72
rect->right = DIV_ROUND_UP(rect->right, 2);
73
rect->bottom = DIV_ROUND_UP(rect->bottom, 2);
77
* 0 <= rect->left < rect->right
78
* 0 <= rect->top < rect->bottom
81
fit_rect_format_inclusive(enum pipe_format format, RECT *rect, int width, int height)
83
const unsigned w = util_format_get_blockwidth(format);
84
const unsigned h = util_format_get_blockheight(format);
86
if (util_format_is_compressed(format)) {
87
rect->left = rect->left - rect->left % w;
88
rect->top = rect->top - rect->top % h;
89
rect->right = (rect->right % w) == 0 ?
91
rect->right - (rect->right % w) + w;
92
rect->bottom = (rect->bottom % h) == 0 ?
94
rect->bottom - (rect->bottom % h) + h;
97
rect->right = MIN2(rect->right, width);
98
rect->bottom = MIN2(rect->bottom, height);
101
static inline boolean
102
rect_to_pipe_box_clamp(struct pipe_box *dst, const RECT *src)
104
rect_to_pipe_box(dst, src);
106
if (dst->width <= 0 || dst->height <= 0) {
107
DBG_FLAG(DBG_UNKNOWN, "Warning: NULL box");
108
dst->width = MAX2(dst->width, 0);
109
dst->height = MAX2(dst->height, 0);
115
static inline boolean
116
rect_to_pipe_box_flip(struct pipe_box *dst, const RECT *src)
118
rect_to_pipe_box(dst, src);
120
if (dst->width >= 0 && dst->height >= 0)
122
if (dst->width < 0) dst->width = -dst->width;
123
if (dst->height < 0) dst->height = -dst->height;
128
rect_to_pipe_box_xy_only(struct pipe_box *dst, const RECT *src)
130
user_warn(src->left > src->right || src->top > src->bottom);
134
dst->width = src->right - src->left;
135
dst->height = src->bottom - src->top;
138
static inline boolean
139
rect_to_pipe_box_xy_only_clamp(struct pipe_box *dst, const RECT *src)
141
rect_to_pipe_box_xy_only(dst, src);
143
if (dst->width <= 0 || dst->height <= 0) {
144
DBG_FLAG(DBG_UNKNOWN, "Warning: NULL box");
145
dst->width = MAX2(dst->width, 0);
146
dst->height = MAX2(dst->height, 0);
153
rect_to_g3d_u_rect(struct u_rect *dst, const RECT *src)
155
user_warn(src->left > src->right || src->top > src->bottom);
158
dst->x1 = src->right;
160
dst->y1 = src->bottom;
164
d3dbox_to_pipe_box(struct pipe_box *dst, const D3DBOX *src)
166
user_warn(src->Left > src->Right);
167
user_warn(src->Top > src->Bottom);
168
user_warn(src->Front > src->Back);
173
dst->width = src->Right - src->Left;
174
dst->height = src->Bottom - src->Top;
175
dst->depth = src->Back - src->Front;
178
static inline D3DFORMAT
179
pipe_to_d3d9_format(enum pipe_format format)
181
return nine_pipe_to_d3d9_format_map[format];
184
static inline boolean
185
fetch4_compatible_format( D3DFORMAT fmt )
187
/* Basically formats with only red channel are allowed (with some exceptions) */
188
static const D3DFORMAT allowed[] = { /* TODO: list incomplete */
200
for (i = 0; i < sizeof(allowed)/sizeof(D3DFORMAT); i++) {
201
if (fmt == allowed[i]) { return TRUE; }
206
/* ATI1 and ATI2 are not officially compressed in d3d9 */
207
static inline boolean
208
compressed_format( D3DFORMAT fmt )
223
static inline boolean
224
depth_stencil_format( D3DFORMAT fmt )
226
static const D3DFORMAT allowed[] = {
234
D3DFMT_D32F_LOCKABLE,
243
for (i = 0; i < sizeof(allowed)/sizeof(D3DFORMAT); i++) {
244
if (fmt == allowed[i]) { return TRUE; }
249
static inline unsigned
250
d3d9_get_pipe_depth_format_bindings(D3DFORMAT format)
260
return PIPE_BIND_DEPTH_STENCIL;
261
case D3DFMT_D32F_LOCKABLE:
262
case D3DFMT_D16_LOCKABLE:
263
case D3DFMT_D32_LOCKABLE:
264
return PIPE_BIND_DEPTH_STENCIL;
268
return PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_SAMPLER_VIEW;
269
default: unreachable("Unexpected format");
273
static inline enum pipe_format
274
d3d9_to_pipe_format_internal(D3DFORMAT format)
276
if (format <= D3DFMT_A2B10G10R10_XR_BIAS)
277
return nine_d3d9_to_pipe_format_map[format];
279
case D3DFMT_INTZ: return PIPE_FORMAT_S8_UINT_Z24_UNORM;
280
case D3DFMT_DF16: return PIPE_FORMAT_Z16_UNORM;
281
case D3DFMT_DF24: return PIPE_FORMAT_X8Z24_UNORM;
282
case D3DFMT_DXT1: return PIPE_FORMAT_DXT1_RGBA;
283
case D3DFMT_DXT2: return PIPE_FORMAT_DXT3_RGBA; /* XXX */
284
case D3DFMT_DXT3: return PIPE_FORMAT_DXT3_RGBA;
285
case D3DFMT_DXT4: return PIPE_FORMAT_DXT5_RGBA; /* XXX */
286
case D3DFMT_DXT5: return PIPE_FORMAT_DXT5_RGBA;
287
case D3DFMT_ATI1: return PIPE_FORMAT_RGTC1_UNORM;
288
case D3DFMT_ATI2: return PIPE_FORMAT_RGTC2_UNORM;
289
case D3DFMT_UYVY: return PIPE_FORMAT_UYVY;
290
case D3DFMT_YUY2: return PIPE_FORMAT_YUYV; /* XXX check */
291
case D3DFMT_NV12: return PIPE_FORMAT_NV12;
292
case D3DFMT_G8R8_G8B8: return PIPE_FORMAT_G8R8_G8B8_UNORM; /* XXX order ? */
293
case D3DFMT_R8G8_B8G8: return PIPE_FORMAT_R8G8_B8G8_UNORM; /* XXX order ? */
294
case D3DFMT_BINARYBUFFER: return PIPE_FORMAT_NONE; /* not a format */
295
case D3DFMT_MULTI2_ARGB8: return PIPE_FORMAT_NONE; /* not supported */
296
case D3DFMT_Y210: /* XXX */
299
case D3DFMT_NULL: /* special cased, only for surfaces */
300
return PIPE_FORMAT_NONE;
302
DBG_FLAG(DBG_UNKNOWN, "unknown D3DFORMAT: 0x%x/%c%c%c%c\n",
303
format, (char)format, (char)(format >> 8),
304
(char)(format >> 16), (char)(format >> 24));
305
return PIPE_FORMAT_NONE;
309
#define format_check_internal(pipe_format) \
310
screen->is_format_supported(screen, pipe_format, target, \
311
sample_count, sample_count, bindings)
313
static inline enum pipe_format
314
d3d9_to_pipe_format_checked(struct pipe_screen *screen,
316
enum pipe_texture_target target,
317
unsigned sample_count,
320
boolean bypass_check)
322
enum pipe_format result;
324
/* We cannot render to depth textures as a render target */
325
if (depth_stencil_format(format) && (bindings & PIPE_BIND_RENDER_TARGET))
326
return PIPE_FORMAT_NONE;
328
result = d3d9_to_pipe_format_internal(format);
329
if (result == PIPE_FORMAT_NONE)
330
return PIPE_FORMAT_NONE;
333
result = util_format_srgb(result);
335
/* bypass_check: Used for D3DPOOL_SCRATCH, which
336
* isn't limited to the formats supported by the
337
* device, and to check we are not using a format
339
if (bypass_check || format_check_internal(result))
342
/* fallback to another format for formats
343
* that match several pipe_format */
345
/* depth buffer formats are not lockable (except those for which it
346
* is precised in the name), so it is ok to match to another similar
347
* format. In all cases, if the app reads the texture with a shader,
348
* it gets depth on r and doesn't get stencil.*/
351
if (format_check_internal(PIPE_FORMAT_Z24_UNORM_S8_UINT))
352
return PIPE_FORMAT_Z24_UNORM_S8_UINT;
356
if (format_check_internal(PIPE_FORMAT_Z24X8_UNORM))
357
return PIPE_FORMAT_Z24X8_UNORM;
359
/* Support for X8L8V8U8 bumpenvmap format with lighting bits.
360
* X8L8V8U8 is commonly supported among dx9 cards.
361
* To avoid precision loss, we use PIPE_FORMAT_R32G32B32X32_FLOAT,
362
* however using PIPE_FORMAT_R8G8B8A8_SNORM should be ok */
363
case D3DFMT_X8L8V8U8:
364
if (bindings & PIPE_BIND_RENDER_TARGET)
365
return PIPE_FORMAT_NONE;
366
if (format_check_internal(PIPE_FORMAT_R32G32B32X32_FLOAT))
367
return PIPE_FORMAT_R32G32B32X32_FLOAT;
369
/* Fallback for YUV formats */
373
if (bindings & PIPE_BIND_RENDER_TARGET)
374
return PIPE_FORMAT_NONE;
375
if (format_check_internal(PIPE_FORMAT_R8G8B8X8_UNORM))
376
return PIPE_FORMAT_R8G8B8X8_UNORM;
380
return PIPE_FORMAT_NONE;
383
/* The quality levels are vendor dependent, so we set our own.
384
* Every quality level has its own sample count and sample
386
* The exact mapping might differ from system to system but thats OK,
387
* as there's no way to gather more information about quality levels
389
* In case of NONMASKABLE multisample map every quality-level
390
* to a MASKABLE MultiSampleType:
395
* If the requested quality level is not available to nearest
396
* matching quality level is used.
397
* If no multisample is available the function sets
398
* multisample to D3DMULTISAMPLE_NONE and returns zero.
400
static inline HRESULT
401
d3dmultisample_type_check(struct pipe_screen *screen,
403
D3DMULTISAMPLE_TYPE *multisample,
404
DWORD multisamplequality,
414
/* Ignores multisamplequality */
415
if (*multisample == D3DMULTISAMPLE_NONE)
418
if (*multisample == D3DMULTISAMPLE_NONMASKABLE) {
419
if (depth_stencil_format(format))
420
bind = d3d9_get_pipe_depth_format_bindings(format);
421
else /* render-target */
422
bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
425
for (i = D3DMULTISAMPLE_2_SAMPLES; i < D3DMULTISAMPLE_16_SAMPLES &&
426
multisamplequality; ++i) {
427
if (d3d9_to_pipe_format_checked(screen, format, PIPE_TEXTURE_2D,
428
i, bind, FALSE, FALSE) != PIPE_FORMAT_NONE) {
429
multisamplequality--;
436
/* Make sure to get an exact match */
437
if (multisamplequality)
438
return D3DERR_INVALIDCALL;
442
static inline const char *
443
d3dformat_to_string(D3DFORMAT fmt)
446
case D3DFMT_UNKNOWN: return "D3DFMT_UNKNOWN";
447
case D3DFMT_R8G8B8: return "D3DFMT_R8G8B8";
448
case D3DFMT_A8R8G8B8: return "D3DFMT_A8R8G8B8";
449
case D3DFMT_X8R8G8B8: return "D3DFMT_X8R8G8B8";
450
case D3DFMT_R5G6B5: return "D3DFMT_R5G6B5";
451
case D3DFMT_X1R5G5B5: return "D3DFMT_X1R5G5B5";
452
case D3DFMT_A1R5G5B5: return "D3DFMT_A1R5G5B5";
453
case D3DFMT_A4R4G4B4: return "D3DFMT_A4R4G4B4";
454
case D3DFMT_R3G3B2: return "D3DFMT_R3G3B2";
455
case D3DFMT_A8: return "D3DFMT_A8";
456
case D3DFMT_A8R3G3B2: return "D3DFMT_A8R3G3B2";
457
case D3DFMT_X4R4G4B4: return "D3DFMT_X4R4G4B4";
458
case D3DFMT_A2B10G10R10: return "D3DFMT_A2B10G10R10";
459
case D3DFMT_A8B8G8R8: return "D3DFMT_A8B8G8R8";
460
case D3DFMT_X8B8G8R8: return "D3DFMT_X8B8G8R8";
461
case D3DFMT_G16R16: return "D3DFMT_G16R16";
462
case D3DFMT_A2R10G10B10: return "D3DFMT_A2R10G10B10";
463
case D3DFMT_A16B16G16R16: return "D3DFMT_A16B16G16R16";
464
case D3DFMT_A8P8: return "D3DFMT_A8P8";
465
case D3DFMT_P8: return "D3DFMT_P8";
466
case D3DFMT_L8: return "D3DFMT_L8";
467
case D3DFMT_A8L8: return "D3DFMT_A8L8";
468
case D3DFMT_A4L4: return "D3DFMT_A4L4";
469
case D3DFMT_V8U8: return "D3DFMT_V8U8";
470
case D3DFMT_L6V5U5: return "D3DFMT_L6V5U5";
471
case D3DFMT_X8L8V8U8: return "D3DFMT_X8L8V8U8";
472
case D3DFMT_Q8W8V8U8: return "D3DFMT_Q8W8V8U8";
473
case D3DFMT_V16U16: return "D3DFMT_V16U16";
474
case D3DFMT_A2W10V10U10: return "D3DFMT_A2W10V10U10";
475
case D3DFMT_UYVY: return "D3DFMT_UYVY";
476
case D3DFMT_R8G8_B8G8: return "D3DFMT_R8G8_B8G8";
477
case D3DFMT_YUY2: return "D3DFMT_YUY2";
478
case D3DFMT_G8R8_G8B8: return "D3DFMT_G8R8_G8B8";
479
case D3DFMT_DXT1: return "D3DFMT_DXT1";
480
case D3DFMT_DXT2: return "D3DFMT_DXT2";
481
case D3DFMT_DXT3: return "D3DFMT_DXT3";
482
case D3DFMT_DXT4: return "D3DFMT_DXT4";
483
case D3DFMT_DXT5: return "D3DFMT_DXT5";
484
case D3DFMT_ATI1: return "D3DFMT_ATI1";
485
case D3DFMT_ATI2: return "D3DFMT_ATI2";
486
case D3DFMT_D16_LOCKABLE: return "D3DFMT_D16_LOCKABLE";
487
case D3DFMT_D32: return "D3DFMT_D32";
488
case D3DFMT_D15S1: return "D3DFMT_D15S1";
489
case D3DFMT_D24S8: return "D3DFMT_D24S8";
490
case D3DFMT_D24X8: return "D3DFMT_D24X8";
491
case D3DFMT_D24X4S4: return "D3DFMT_D24X4S4";
492
case D3DFMT_D16: return "D3DFMT_D16";
493
case D3DFMT_D32F_LOCKABLE: return "D3DFMT_D32F_LOCKABLE";
494
case D3DFMT_D24FS8: return "D3DFMT_D24FS8";
495
case D3DFMT_D32_LOCKABLE: return "D3DFMT_D32_LOCKABLE";
496
case D3DFMT_S8_LOCKABLE: return "D3DFMT_S8_LOCKABLE";
497
case D3DFMT_L16: return "D3DFMT_L16";
498
case D3DFMT_VERTEXDATA: return "D3DFMT_VERTEXDATA";
499
case D3DFMT_INDEX16: return "D3DFMT_INDEX16";
500
case D3DFMT_INDEX32: return "D3DFMT_INDEX32";
501
case D3DFMT_Q16W16V16U16: return "D3DFMT_Q16W16V16U16";
502
case D3DFMT_MULTI2_ARGB8: return "D3DFMT_MULTI2_ARGB8";
503
case D3DFMT_R16F: return "D3DFMT_R16F";
504
case D3DFMT_G16R16F: return "D3DFMT_G16R16F";
505
case D3DFMT_A16B16G16R16F: return "D3DFMT_A16B16G16R16F";
506
case D3DFMT_R32F: return "D3DFMT_R32F";
507
case D3DFMT_G32R32F: return "D3DFMT_G32R32F";
508
case D3DFMT_A32B32G32R32F: return "D3DFMT_A32B32G32R32F";
509
case D3DFMT_CxV8U8: return "D3DFMT_CxV8U8";
510
case D3DFMT_A1: return "D3DFMT_A1";
511
case D3DFMT_A2B10G10R10_XR_BIAS: return "D3DFMT_A2B10G10R10_XR_BIAS";
512
case D3DFMT_BINARYBUFFER: return "D3DFMT_BINARYBUFFER";
513
case D3DFMT_DF16: return "D3DFMT_DF16";
514
case D3DFMT_DF24: return "D3DFMT_DF24";
515
case D3DFMT_INTZ: return "D3DFMT_INTZ";
516
case D3DFMT_NVDB: return "D3DFMT_NVDB";
517
case D3DFMT_RESZ: return "D3DFMT_RESZ";
518
case D3DFMT_NULL: return "D3DFMT_NULL";
519
case D3DFMT_ATOC: return "D3DFMT_ATOC";
526
static inline unsigned
527
nine_fvf_stride( DWORD fvf )
529
unsigned texcount, i, size = 0;
531
switch (fvf & D3DFVF_POSITION_MASK) {
532
case D3DFVF_XYZ: size += 3*4; break;
533
case D3DFVF_XYZRHW: size += 4*4; break;
534
case D3DFVF_XYZB1: size += 4*4; break;
535
case D3DFVF_XYZB2: size += 5*4; break;
536
case D3DFVF_XYZB3: size += 6*4; break;
537
case D3DFVF_XYZB4: size += 7*4; break;
538
case D3DFVF_XYZB5: size += 8*4; break;
539
case D3DFVF_XYZW: size += 4*4; break;
541
user_warn("Position doesn't match any known combination.");
545
if (fvf & D3DFVF_NORMAL) { size += 3*4; }
546
if (fvf & D3DFVF_PSIZE) { size += 1*4; }
547
if (fvf & D3DFVF_DIFFUSE) { size += 1*4; }
548
if (fvf & D3DFVF_SPECULAR) { size += 1*4; }
550
texcount = (fvf >> D3DFVF_TEXCOUNT_SHIFT) & D3DFVF_TEXCOUNT_MASK;
551
if (user_error(texcount <= 8))
554
for (i = 0; i < texcount; ++i) {
555
unsigned texformat = (fvf>>(16+i*2))&0x3;
556
/* texformats are defined having been shifted around so 1=3,2=0,3=1,4=2
557
* meaning we can just do this instead of the switch below */
558
size += (((texformat+1)&0x3)+1)*4;
562
case D3DFVF_TEXTUREFORMAT1: size += 1*4;
563
case D3DFVF_TEXTUREFORMAT2: size += 2*4;
564
case D3DFVF_TEXTUREFORMAT3: size += 3*4;
565
case D3DFVF_TEXTUREFORMAT4: size += 4*4;
574
d3dcolor_to_rgba(float *rgba, D3DCOLOR color)
576
rgba[0] = (float)((color >> 16) & 0xFF) / 0xFF;
577
rgba[1] = (float)((color >> 8) & 0xFF) / 0xFF;
578
rgba[2] = (float)((color >> 0) & 0xFF) / 0xFF;
579
rgba[3] = (float)((color >> 24) & 0xFF) / 0xFF;
583
d3dcolor_to_pipe_color_union(union pipe_color_union *rgba, D3DCOLOR color)
585
d3dcolor_to_rgba(&rgba->f[0], color);
588
static inline unsigned
589
d3dprimitivetype_to_pipe_prim(D3DPRIMITIVETYPE prim)
592
case D3DPT_POINTLIST: return PIPE_PRIM_POINTS;
593
case D3DPT_LINELIST: return PIPE_PRIM_LINES;
594
case D3DPT_LINESTRIP: return PIPE_PRIM_LINE_STRIP;
595
case D3DPT_TRIANGLELIST: return PIPE_PRIM_TRIANGLES;
596
case D3DPT_TRIANGLESTRIP: return PIPE_PRIM_TRIANGLE_STRIP;
597
case D3DPT_TRIANGLEFAN: return PIPE_PRIM_TRIANGLE_FAN;
600
return PIPE_PRIM_POINTS;
604
static inline unsigned
605
prim_count_to_vertex_count(D3DPRIMITIVETYPE prim, UINT count)
608
case D3DPT_POINTLIST: return count;
609
case D3DPT_LINELIST: return count * 2;
610
case D3DPT_LINESTRIP: return count + 1;
611
case D3DPT_TRIANGLELIST: return count * 3;
612
case D3DPT_TRIANGLESTRIP: return count + 2;
613
case D3DPT_TRIANGLEFAN: return count + 2;
620
static inline unsigned
621
d3dcmpfunc_to_pipe_func(D3DCMPFUNC func)
624
case D3DCMP_NEVER: return PIPE_FUNC_NEVER;
625
case D3DCMP_LESS: return PIPE_FUNC_LESS;
626
case D3DCMP_EQUAL: return PIPE_FUNC_EQUAL;
627
case D3DCMP_LESSEQUAL: return PIPE_FUNC_LEQUAL;
628
case D3DCMP_GREATER: return PIPE_FUNC_GREATER;
629
case D3DCMP_NOTEQUAL: return PIPE_FUNC_NOTEQUAL;
630
case D3DCMP_GREATEREQUAL: return PIPE_FUNC_GEQUAL;
631
case D3DCMP_ALWAYS: return PIPE_FUNC_ALWAYS;
632
case D3DCMP_NEVER_ZERO: return PIPE_FUNC_NEVER; // Tested on windows + ATI HD5770
635
return PIPE_FUNC_NEVER;
639
static inline unsigned
640
d3dstencilop_to_pipe_stencil_op(D3DSTENCILOP op)
643
case D3DSTENCILOP_KEEP: return PIPE_STENCIL_OP_KEEP;
644
case D3DSTENCILOP_ZERO: return PIPE_STENCIL_OP_ZERO;
645
case D3DSTENCILOP_REPLACE: return PIPE_STENCIL_OP_REPLACE;
646
case D3DSTENCILOP_INCRSAT: return PIPE_STENCIL_OP_INCR;
647
case D3DSTENCILOP_DECRSAT: return PIPE_STENCIL_OP_DECR;
648
case D3DSTENCILOP_INVERT: return PIPE_STENCIL_OP_INVERT;
649
case D3DSTENCILOP_INCR: return PIPE_STENCIL_OP_INCR_WRAP;
650
case D3DSTENCILOP_DECR: return PIPE_STENCIL_OP_DECR_WRAP;
652
return PIPE_STENCIL_OP_ZERO;
656
static inline unsigned
657
d3dcull_to_pipe_face(D3DCULL cull)
660
case D3DCULL_NONE: return PIPE_FACE_NONE;
661
case D3DCULL_CW: return PIPE_FACE_FRONT;
662
case D3DCULL_CCW: return PIPE_FACE_BACK;
665
return PIPE_FACE_NONE;
669
static inline unsigned
670
d3dfillmode_to_pipe_polygon_mode(D3DFILLMODE mode)
673
case D3DFILL_POINT: return PIPE_POLYGON_MODE_POINT;
674
case D3DFILL_WIREFRAME: return PIPE_POLYGON_MODE_LINE;
675
case D3DFILL_SOLID: return PIPE_POLYGON_MODE_FILL;
676
case D3DFILL_SOLID_ZERO:return PIPE_POLYGON_MODE_FILL;
679
return PIPE_POLYGON_MODE_FILL;
683
static inline unsigned
684
d3dblendop_to_pipe_blend(D3DBLENDOP op)
687
case D3DBLENDOP_ADD: return PIPE_BLEND_ADD;
688
case D3DBLENDOP_SUBTRACT: return PIPE_BLEND_SUBTRACT;
689
case D3DBLENDOP_REVSUBTRACT: return PIPE_BLEND_REVERSE_SUBTRACT;
690
case D3DBLENDOP_MIN: return PIPE_BLEND_MIN;
691
case D3DBLENDOP_MAX: return PIPE_BLEND_MAX;
694
return PIPE_BLEND_ADD;
698
/* NOTE: The COLOR factors for are equal to the ALPHA ones for alpha.
699
* Drivers may check RGB and ALPHA factors for equality so we should not
700
* simply substitute the ALPHA variants.
702
static inline unsigned
703
d3dblend_alpha_to_pipe_blendfactor(D3DBLEND b)
706
case D3DBLEND_ZERO: return PIPE_BLENDFACTOR_ZERO;
707
case D3DBLEND_ONE: return PIPE_BLENDFACTOR_ONE;
708
case D3DBLEND_SRCCOLOR: return PIPE_BLENDFACTOR_SRC_COLOR/*ALPHA*/;
709
case D3DBLEND_INVSRCCOLOR: return PIPE_BLENDFACTOR_INV_SRC_COLOR/*ALPHA*/;
710
case D3DBLEND_SRCALPHA: return PIPE_BLENDFACTOR_SRC_ALPHA;
711
case D3DBLEND_INVSRCALPHA: return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
712
case D3DBLEND_DESTALPHA: return PIPE_BLENDFACTOR_DST_ALPHA;
713
case D3DBLEND_INVDESTALPHA: return PIPE_BLENDFACTOR_INV_DST_ALPHA;
714
case D3DBLEND_DESTCOLOR: return PIPE_BLENDFACTOR_DST_COLOR/*ALPHA*/;
715
case D3DBLEND_INVDESTCOLOR: return PIPE_BLENDFACTOR_INV_DST_COLOR/*ALPHA*/;
716
case D3DBLEND_SRCALPHASAT: return PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE;
717
case D3DBLEND_BOTHSRCALPHA: return PIPE_BLENDFACTOR_SRC_ALPHA;
718
case D3DBLEND_BOTHINVSRCALPHA: return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
719
case D3DBLEND_BLENDFACTOR: return PIPE_BLENDFACTOR_CONST_COLOR/*ALPHA*/;
720
case D3DBLEND_INVBLENDFACTOR: return PIPE_BLENDFACTOR_INV_CONST_COLOR/*ALPHA*/;
721
case D3DBLEND_SRCCOLOR2: return PIPE_BLENDFACTOR_ONE; /* XXX */
722
case D3DBLEND_INVSRCCOLOR2: return PIPE_BLENDFACTOR_ZERO; /* XXX */
724
DBG_FLAG(DBG_UNKNOWN, "Unhandled blend factor %d\n", b);
725
return PIPE_BLENDFACTOR_ZERO;
729
static inline unsigned
730
d3dblend_color_to_pipe_blendfactor(D3DBLEND b)
733
case D3DBLEND_ZERO: return PIPE_BLENDFACTOR_ZERO;
734
case D3DBLEND_ONE: return PIPE_BLENDFACTOR_ONE;
735
case D3DBLEND_SRCCOLOR: return PIPE_BLENDFACTOR_SRC_COLOR;
736
case D3DBLEND_INVSRCCOLOR: return PIPE_BLENDFACTOR_INV_SRC_COLOR;
737
case D3DBLEND_SRCALPHA: return PIPE_BLENDFACTOR_SRC_ALPHA;
738
case D3DBLEND_INVSRCALPHA: return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
739
case D3DBLEND_DESTALPHA: return PIPE_BLENDFACTOR_DST_ALPHA;
740
case D3DBLEND_INVDESTALPHA: return PIPE_BLENDFACTOR_INV_DST_ALPHA;
741
case D3DBLEND_DESTCOLOR: return PIPE_BLENDFACTOR_DST_COLOR;
742
case D3DBLEND_INVDESTCOLOR: return PIPE_BLENDFACTOR_INV_DST_COLOR;
743
case D3DBLEND_SRCALPHASAT: return PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE;
744
case D3DBLEND_BOTHSRCALPHA: return PIPE_BLENDFACTOR_SRC_ALPHA;
745
case D3DBLEND_BOTHINVSRCALPHA: return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
746
case D3DBLEND_BLENDFACTOR: return PIPE_BLENDFACTOR_CONST_COLOR;
747
case D3DBLEND_INVBLENDFACTOR: return PIPE_BLENDFACTOR_INV_CONST_COLOR;
748
case D3DBLEND_SRCCOLOR2: return PIPE_BLENDFACTOR_SRC1_COLOR;
749
case D3DBLEND_INVSRCCOLOR2: return PIPE_BLENDFACTOR_INV_SRC1_COLOR;
751
DBG_FLAG(DBG_UNKNOWN, "Unhandled blend factor %d\n", b);
752
return PIPE_BLENDFACTOR_ZERO;
756
static inline unsigned
757
d3dtextureaddress_to_pipe_tex_wrap(D3DTEXTUREADDRESS addr)
760
case D3DTADDRESS_WRAP: return PIPE_TEX_WRAP_REPEAT;
761
case D3DTADDRESS_MIRROR: return PIPE_TEX_WRAP_MIRROR_REPEAT;
762
case D3DTADDRESS_CLAMP: return PIPE_TEX_WRAP_CLAMP_TO_EDGE;
763
case D3DTADDRESS_BORDER: return PIPE_TEX_WRAP_CLAMP_TO_BORDER;
764
case D3DTADDRESS_MIRRORONCE: return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;
767
return PIPE_TEX_WRAP_CLAMP_TO_EDGE;
771
static inline unsigned
772
d3dtexturefiltertype_to_pipe_tex_filter(D3DTEXTUREFILTERTYPE filter)
775
case D3DTEXF_POINT: return PIPE_TEX_FILTER_NEAREST;
776
case D3DTEXF_LINEAR: return PIPE_TEX_FILTER_LINEAR;
777
case D3DTEXF_ANISOTROPIC: return PIPE_TEX_FILTER_LINEAR;
780
case D3DTEXF_PYRAMIDALQUAD:
781
case D3DTEXF_GAUSSIANQUAD:
782
case D3DTEXF_CONVOLUTIONMONO:
785
return PIPE_TEX_FILTER_NEAREST;
789
static inline unsigned
790
d3dtexturefiltertype_to_pipe_tex_mipfilter(D3DTEXTUREFILTERTYPE filter)
793
case D3DTEXF_NONE: return PIPE_TEX_MIPFILTER_NONE;
794
case D3DTEXF_POINT: return PIPE_TEX_FILTER_NEAREST;
795
case D3DTEXF_LINEAR: return PIPE_TEX_FILTER_LINEAR;
796
case D3DTEXF_ANISOTROPIC: return PIPE_TEX_FILTER_LINEAR;
798
case D3DTEXF_PYRAMIDALQUAD:
799
case D3DTEXF_GAUSSIANQUAD:
800
case D3DTEXF_CONVOLUTIONMONO:
803
return PIPE_TEX_MIPFILTER_NONE;
807
static inline unsigned nine_format_get_stride(enum pipe_format format,
810
unsigned stride = util_format_get_stride(format, width);
812
return align(stride, 4);
815
static inline unsigned nine_format_get_level_alloc_size(enum pipe_format format,
822
w = u_minify(width, level);
823
h = u_minify(height, level);
824
if (is_ATI1_ATI2(format)) {
825
/* For "unknown" formats like ATIx use width * height bytes */
827
} else if (format == PIPE_FORMAT_NONE) { /* D3DFMT_NULL */
830
size = nine_format_get_stride(format, w) *
831
util_format_get_nblocksy(format, h);
837
static inline unsigned nine_format_get_size_and_offsets(enum pipe_format format,
843
unsigned l, w, h, size = 0;
845
for (l = 0; l <= last_level; ++l) {
846
w = u_minify(width, l);
847
h = u_minify(height, l);
849
if (is_ATI1_ATI2(format)) {
850
/* For "unknown" formats like ATIx use width * height bytes */
853
size += nine_format_get_stride(format, w) *
854
util_format_get_nblocksy(format, h);
861
#endif /* _NINE_PIPE_H_ */
added
removed
src/gallium/frontends/nine/nine_pipe.h
