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 /* ATI1 and ATI2 are not officially compressed in d3d9 */
185 static inline boolean
186 compressed_format( D3DFORMAT fmt
)
201 static inline boolean
202 depth_stencil_format( D3DFORMAT fmt
)
204 static const D3DFORMAT allowed
[] = {
212 D3DFMT_D32F_LOCKABLE
,
221 for (i
= 0; i
< sizeof(allowed
)/sizeof(D3DFORMAT
); i
++) {
222 if (fmt
== allowed
[i
]) { return TRUE
; }
227 static inline unsigned
228 d3d9_get_pipe_depth_format_bindings(D3DFORMAT format
)
238 return PIPE_BIND_DEPTH_STENCIL
;
239 case D3DFMT_D32F_LOCKABLE
:
240 case D3DFMT_D16_LOCKABLE
:
241 case D3DFMT_D32_LOCKABLE
:
242 return PIPE_BIND_DEPTH_STENCIL
;
246 return PIPE_BIND_DEPTH_STENCIL
| PIPE_BIND_SAMPLER_VIEW
;
247 default: unreachable("Unexpected format");
251 static inline enum pipe_format
252 d3d9_to_pipe_format_internal(D3DFORMAT format
)
254 if (format
<= D3DFMT_A2B10G10R10_XR_BIAS
)
255 return nine_d3d9_to_pipe_format_map
[format
];
257 case D3DFMT_INTZ
: return PIPE_FORMAT_S8_UINT_Z24_UNORM
;
258 case D3DFMT_DF16
: return PIPE_FORMAT_Z16_UNORM
;
259 case D3DFMT_DXT1
: return PIPE_FORMAT_DXT1_RGBA
;
260 case D3DFMT_DXT2
: return PIPE_FORMAT_DXT3_RGBA
; /* XXX */
261 case D3DFMT_DXT3
: return PIPE_FORMAT_DXT3_RGBA
;
262 case D3DFMT_DXT4
: return PIPE_FORMAT_DXT5_RGBA
; /* XXX */
263 case D3DFMT_DXT5
: return PIPE_FORMAT_DXT5_RGBA
;
264 case D3DFMT_ATI1
: return PIPE_FORMAT_RGTC1_UNORM
;
265 case D3DFMT_ATI2
: return PIPE_FORMAT_RGTC2_UNORM
;
266 case D3DFMT_UYVY
: return PIPE_FORMAT_UYVY
;
267 case D3DFMT_YUY2
: return PIPE_FORMAT_YUYV
; /* XXX check */
268 case D3DFMT_NV12
: return PIPE_FORMAT_NV12
;
269 case D3DFMT_G8R8_G8B8
: return PIPE_FORMAT_G8R8_G8B8_UNORM
; /* XXX order ? */
270 case D3DFMT_R8G8_B8G8
: return PIPE_FORMAT_R8G8_B8G8_UNORM
; /* XXX order ? */
271 case D3DFMT_BINARYBUFFER
: return PIPE_FORMAT_NONE
; /* not a format */
272 case D3DFMT_MULTI2_ARGB8
: return PIPE_FORMAT_NONE
; /* not supported */
273 case D3DFMT_Y210
: /* XXX */
276 case D3DFMT_DF24
: /* Similar to D3DFMT_DF16 but for 24-bits.
277 We don't advertise it because when it is supported, Fetch-4 is
278 supposed to be supported, which we don't support yet. */
279 case D3DFMT_NULL
: /* special cased, only for surfaces */
280 return PIPE_FORMAT_NONE
;
282 DBG_FLAG(DBG_UNKNOWN
, "unknown D3DFORMAT: 0x%x/%c%c%c%c\n",
283 format
, (char)format
, (char)(format
>> 8),
284 (char)(format
>> 16), (char)(format
>> 24));
285 return PIPE_FORMAT_NONE
;
289 #define format_check_internal(pipe_format) \
290 screen->is_format_supported(screen, pipe_format, target, \
291 sample_count, sample_count, bindings)
293 static inline enum pipe_format
294 d3d9_to_pipe_format_checked(struct pipe_screen
*screen
,
296 enum pipe_texture_target target
,
297 unsigned sample_count
,
300 boolean bypass_check
)
302 enum pipe_format result
;
304 result
= d3d9_to_pipe_format_internal(format
);
305 if (result
== PIPE_FORMAT_NONE
)
306 return PIPE_FORMAT_NONE
;
309 result
= util_format_srgb(result
);
311 /* bypass_check: Used for D3DPOOL_SCRATCH, which
312 * isn't limited to the formats supported by the
313 * device, and to check we are not using a format
315 if (bypass_check
|| format_check_internal(result
))
318 /* fallback to another format for formats
319 * that match several pipe_format */
321 /* depth buffer formats are not lockable (except those for which it
322 * is precised in the name), so it is ok to match to another similar
323 * format. In all cases, if the app reads the texture with a shader,
324 * it gets depth on r and doesn't get stencil.*/
327 if (format_check_internal(PIPE_FORMAT_Z24_UNORM_S8_UINT
))
328 return PIPE_FORMAT_Z24_UNORM_S8_UINT
;
331 if (format_check_internal(PIPE_FORMAT_Z24X8_UNORM
))
332 return PIPE_FORMAT_Z24X8_UNORM
;
334 /* Support for X8L8V8U8 bumpenvmap format with lighting bits.
335 * X8L8V8U8 is commonly supported among dx9 cards.
336 * To avoid precision loss, we use PIPE_FORMAT_R32G32B32X32_FLOAT,
337 * however using PIPE_FORMAT_R8G8B8A8_SNORM should be ok */
338 case D3DFMT_X8L8V8U8
:
339 if (bindings
& PIPE_BIND_RENDER_TARGET
)
340 return PIPE_FORMAT_NONE
;
341 if (format_check_internal(PIPE_FORMAT_R32G32B32X32_FLOAT
))
342 return PIPE_FORMAT_R32G32B32X32_FLOAT
;
346 return PIPE_FORMAT_NONE
;
349 /* The quality levels are vendor dependent, so we set our own.
350 * Every quality level has its own sample count and sample
352 * The exact mapping might differ from system to system but thats OK,
353 * as there's no way to gather more information about quality levels
355 * In case of NONMASKABLE multisample map every quality-level
356 * to a MASKABLE MultiSampleType:
361 * If the requested quality level is not available to nearest
362 * matching quality level is used.
363 * If no multisample is available the function sets
364 * multisample to D3DMULTISAMPLE_NONE and returns zero.
366 static inline HRESULT
367 d3dmultisample_type_check(struct pipe_screen
*screen
,
369 D3DMULTISAMPLE_TYPE
*multisample
,
370 DWORD multisamplequality
,
380 /* Ignores multisamplequality */
381 if (*multisample
== D3DMULTISAMPLE_NONE
)
384 if (*multisample
== D3DMULTISAMPLE_NONMASKABLE
) {
385 if (depth_stencil_format(format
))
386 bind
= d3d9_get_pipe_depth_format_bindings(format
);
387 else /* render-target */
388 bind
= PIPE_BIND_SAMPLER_VIEW
| PIPE_BIND_RENDER_TARGET
;
391 for (i
= D3DMULTISAMPLE_2_SAMPLES
; i
< D3DMULTISAMPLE_16_SAMPLES
&&
392 multisamplequality
; ++i
) {
393 if (d3d9_to_pipe_format_checked(screen
, format
, PIPE_TEXTURE_2D
,
394 i
, bind
, FALSE
, FALSE
) != PIPE_FORMAT_NONE
) {
395 multisamplequality
--;
402 /* Make sure to get an exact match */
403 if (multisamplequality
)
404 return D3DERR_INVALIDCALL
;
408 static inline const char *
409 d3dformat_to_string(D3DFORMAT fmt
)
412 case D3DFMT_UNKNOWN
: return "D3DFMT_UNKNOWN";
413 case D3DFMT_R8G8B8
: return "D3DFMT_R8G8B8";
414 case D3DFMT_A8R8G8B8
: return "D3DFMT_A8R8G8B8";
415 case D3DFMT_X8R8G8B8
: return "D3DFMT_X8R8G8B8";
416 case D3DFMT_R5G6B5
: return "D3DFMT_R5G6B5";
417 case D3DFMT_X1R5G5B5
: return "D3DFMT_X1R5G5B5";
418 case D3DFMT_A1R5G5B5
: return "D3DFMT_A1R5G5B5";
419 case D3DFMT_A4R4G4B4
: return "D3DFMT_A4R4G4B4";
420 case D3DFMT_R3G3B2
: return "D3DFMT_R3G3B2";
421 case D3DFMT_A8
: return "D3DFMT_A8";
422 case D3DFMT_A8R3G3B2
: return "D3DFMT_A8R3G3B2";
423 case D3DFMT_X4R4G4B4
: return "D3DFMT_X4R4G4B4";
424 case D3DFMT_A2B10G10R10
: return "D3DFMT_A2B10G10R10";
425 case D3DFMT_A8B8G8R8
: return "D3DFMT_A8B8G8R8";
426 case D3DFMT_X8B8G8R8
: return "D3DFMT_X8B8G8R8";
427 case D3DFMT_G16R16
: return "D3DFMT_G16R16";
428 case D3DFMT_A2R10G10B10
: return "D3DFMT_A2R10G10B10";
429 case D3DFMT_A16B16G16R16
: return "D3DFMT_A16B16G16R16";
430 case D3DFMT_A8P8
: return "D3DFMT_A8P8";
431 case D3DFMT_P8
: return "D3DFMT_P8";
432 case D3DFMT_L8
: return "D3DFMT_L8";
433 case D3DFMT_A8L8
: return "D3DFMT_A8L8";
434 case D3DFMT_A4L4
: return "D3DFMT_A4L4";
435 case D3DFMT_V8U8
: return "D3DFMT_V8U8";
436 case D3DFMT_L6V5U5
: return "D3DFMT_L6V5U5";
437 case D3DFMT_X8L8V8U8
: return "D3DFMT_X8L8V8U8";
438 case D3DFMT_Q8W8V8U8
: return "D3DFMT_Q8W8V8U8";
439 case D3DFMT_V16U16
: return "D3DFMT_V16U16";
440 case D3DFMT_A2W10V10U10
: return "D3DFMT_A2W10V10U10";
441 case D3DFMT_UYVY
: return "D3DFMT_UYVY";
442 case D3DFMT_R8G8_B8G8
: return "D3DFMT_R8G8_B8G8";
443 case D3DFMT_YUY2
: return "D3DFMT_YUY2";
444 case D3DFMT_G8R8_G8B8
: return "D3DFMT_G8R8_G8B8";
445 case D3DFMT_DXT1
: return "D3DFMT_DXT1";
446 case D3DFMT_DXT2
: return "D3DFMT_DXT2";
447 case D3DFMT_DXT3
: return "D3DFMT_DXT3";
448 case D3DFMT_DXT4
: return "D3DFMT_DXT4";
449 case D3DFMT_DXT5
: return "D3DFMT_DXT5";
450 case D3DFMT_ATI1
: return "D3DFMT_ATI1";
451 case D3DFMT_ATI2
: return "D3DFMT_ATI2";
452 case D3DFMT_D16_LOCKABLE
: return "D3DFMT_D16_LOCKABLE";
453 case D3DFMT_D32
: return "D3DFMT_D32";
454 case D3DFMT_D15S1
: return "D3DFMT_D15S1";
455 case D3DFMT_D24S8
: return "D3DFMT_D24S8";
456 case D3DFMT_D24X8
: return "D3DFMT_D24X8";
457 case D3DFMT_D24X4S4
: return "D3DFMT_D24X4S4";
458 case D3DFMT_D16
: return "D3DFMT_D16";
459 case D3DFMT_D32F_LOCKABLE
: return "D3DFMT_D32F_LOCKABLE";
460 case D3DFMT_D24FS8
: return "D3DFMT_D24FS8";
461 case D3DFMT_D32_LOCKABLE
: return "D3DFMT_D32_LOCKABLE";
462 case D3DFMT_S8_LOCKABLE
: return "D3DFMT_S8_LOCKABLE";
463 case D3DFMT_L16
: return "D3DFMT_L16";
464 case D3DFMT_VERTEXDATA
: return "D3DFMT_VERTEXDATA";
465 case D3DFMT_INDEX16
: return "D3DFMT_INDEX16";
466 case D3DFMT_INDEX32
: return "D3DFMT_INDEX32";
467 case D3DFMT_Q16W16V16U16
: return "D3DFMT_Q16W16V16U16";
468 case D3DFMT_MULTI2_ARGB8
: return "D3DFMT_MULTI2_ARGB8";
469 case D3DFMT_R16F
: return "D3DFMT_R16F";
470 case D3DFMT_G16R16F
: return "D3DFMT_G16R16F";
471 case D3DFMT_A16B16G16R16F
: return "D3DFMT_A16B16G16R16F";
472 case D3DFMT_R32F
: return "D3DFMT_R32F";
473 case D3DFMT_G32R32F
: return "D3DFMT_G32R32F";
474 case D3DFMT_A32B32G32R32F
: return "D3DFMT_A32B32G32R32F";
475 case D3DFMT_CxV8U8
: return "D3DFMT_CxV8U8";
476 case D3DFMT_A1
: return "D3DFMT_A1";
477 case D3DFMT_A2B10G10R10_XR_BIAS
: return "D3DFMT_A2B10G10R10_XR_BIAS";
478 case D3DFMT_BINARYBUFFER
: return "D3DFMT_BINARYBUFFER";
479 case D3DFMT_DF16
: return "D3DFMT_DF16";
480 case D3DFMT_DF24
: return "D3DFMT_DF24";
481 case D3DFMT_INTZ
: return "D3DFMT_INTZ";
482 case D3DFMT_NVDB
: return "D3DFMT_NVDB";
483 case D3DFMT_RESZ
: return "D3DFMT_RESZ";
484 case D3DFMT_NULL
: return "D3DFMT_NULL";
485 case D3DFMT_ATOC
: return "D3DFMT_ATOC";
492 static inline unsigned
493 nine_fvf_stride( DWORD fvf
)
495 unsigned texcount
, i
, size
= 0;
497 switch (fvf
& D3DFVF_POSITION_MASK
) {
498 case D3DFVF_XYZ
: size
+= 3*4; break;
499 case D3DFVF_XYZRHW
: size
+= 4*4; break;
500 case D3DFVF_XYZB1
: size
+= 4*4; break;
501 case D3DFVF_XYZB2
: size
+= 5*4; break;
502 case D3DFVF_XYZB3
: size
+= 6*4; break;
503 case D3DFVF_XYZB4
: size
+= 7*4; break;
504 case D3DFVF_XYZB5
: size
+= 8*4; break;
505 case D3DFVF_XYZW
: size
+= 4*4; break;
507 user_warn("Position doesn't match any known combination.");
511 if (fvf
& D3DFVF_NORMAL
) { size
+= 3*4; }
512 if (fvf
& D3DFVF_PSIZE
) { size
+= 1*4; }
513 if (fvf
& D3DFVF_DIFFUSE
) { size
+= 1*4; }
514 if (fvf
& D3DFVF_SPECULAR
) { size
+= 1*4; }
516 texcount
= (fvf
>> D3DFVF_TEXCOUNT_SHIFT
) & D3DFVF_TEXCOUNT_MASK
;
517 if (user_error(texcount
<= 8))
520 for (i
= 0; i
< texcount
; ++i
) {
521 unsigned texformat
= (fvf
>>(16+i
*2))&0x3;
522 /* texformats are defined having been shifted around so 1=3,2=0,3=1,4=2
523 * meaning we can just do this instead of the switch below */
524 size
+= (((texformat
+1)&0x3)+1)*4;
528 case D3DFVF_TEXTUREFORMAT1: size += 1*4;
529 case D3DFVF_TEXTUREFORMAT2: size += 2*4;
530 case D3DFVF_TEXTUREFORMAT3: size += 3*4;
531 case D3DFVF_TEXTUREFORMAT4: size += 4*4;
540 d3dcolor_to_rgba(float *rgba
, D3DCOLOR color
)
542 rgba
[0] = (float)((color
>> 16) & 0xFF) / 0xFF;
543 rgba
[1] = (float)((color
>> 8) & 0xFF) / 0xFF;
544 rgba
[2] = (float)((color
>> 0) & 0xFF) / 0xFF;
545 rgba
[3] = (float)((color
>> 24) & 0xFF) / 0xFF;
549 d3dcolor_to_pipe_color_union(union pipe_color_union
*rgba
, D3DCOLOR color
)
551 d3dcolor_to_rgba(&rgba
->f
[0], color
);
554 static inline unsigned
555 d3dprimitivetype_to_pipe_prim(D3DPRIMITIVETYPE prim
)
558 case D3DPT_POINTLIST
: return PIPE_PRIM_POINTS
;
559 case D3DPT_LINELIST
: return PIPE_PRIM_LINES
;
560 case D3DPT_LINESTRIP
: return PIPE_PRIM_LINE_STRIP
;
561 case D3DPT_TRIANGLELIST
: return PIPE_PRIM_TRIANGLES
;
562 case D3DPT_TRIANGLESTRIP
: return PIPE_PRIM_TRIANGLE_STRIP
;
563 case D3DPT_TRIANGLEFAN
: return PIPE_PRIM_TRIANGLE_FAN
;
566 return PIPE_PRIM_POINTS
;
570 static inline unsigned
571 prim_count_to_vertex_count(D3DPRIMITIVETYPE prim
, UINT count
)
574 case D3DPT_POINTLIST
: return count
;
575 case D3DPT_LINELIST
: return count
* 2;
576 case D3DPT_LINESTRIP
: return count
+ 1;
577 case D3DPT_TRIANGLELIST
: return count
* 3;
578 case D3DPT_TRIANGLESTRIP
: return count
+ 2;
579 case D3DPT_TRIANGLEFAN
: return count
+ 2;
586 static inline unsigned
587 d3dcmpfunc_to_pipe_func(D3DCMPFUNC func
)
590 case D3DCMP_NEVER
: return PIPE_FUNC_NEVER
;
591 case D3DCMP_LESS
: return PIPE_FUNC_LESS
;
592 case D3DCMP_EQUAL
: return PIPE_FUNC_EQUAL
;
593 case D3DCMP_LESSEQUAL
: return PIPE_FUNC_LEQUAL
;
594 case D3DCMP_GREATER
: return PIPE_FUNC_GREATER
;
595 case D3DCMP_NOTEQUAL
: return PIPE_FUNC_NOTEQUAL
;
596 case D3DCMP_GREATEREQUAL
: return PIPE_FUNC_GEQUAL
;
597 case D3DCMP_ALWAYS
: return PIPE_FUNC_ALWAYS
;
598 case D3DCMP_NEVER_ZERO
: return PIPE_FUNC_NEVER
; // Tested on windows + ATI HD5770
601 return PIPE_FUNC_NEVER
;
605 static inline unsigned
606 d3dstencilop_to_pipe_stencil_op(D3DSTENCILOP op
)
609 case D3DSTENCILOP_KEEP
: return PIPE_STENCIL_OP_KEEP
;
610 case D3DSTENCILOP_ZERO
: return PIPE_STENCIL_OP_ZERO
;
611 case D3DSTENCILOP_REPLACE
: return PIPE_STENCIL_OP_REPLACE
;
612 case D3DSTENCILOP_INCRSAT
: return PIPE_STENCIL_OP_INCR
;
613 case D3DSTENCILOP_DECRSAT
: return PIPE_STENCIL_OP_DECR
;
614 case D3DSTENCILOP_INVERT
: return PIPE_STENCIL_OP_INVERT
;
615 case D3DSTENCILOP_INCR
: return PIPE_STENCIL_OP_INCR_WRAP
;
616 case D3DSTENCILOP_DECR
: return PIPE_STENCIL_OP_DECR_WRAP
;
618 return PIPE_STENCIL_OP_ZERO
;
622 static inline unsigned
623 d3dcull_to_pipe_face(D3DCULL cull
)
626 case D3DCULL_NONE
: return PIPE_FACE_NONE
;
627 case D3DCULL_CW
: return PIPE_FACE_FRONT
;
628 case D3DCULL_CCW
: return PIPE_FACE_BACK
;
631 return PIPE_FACE_NONE
;
635 static inline unsigned
636 d3dfillmode_to_pipe_polygon_mode(D3DFILLMODE mode
)
639 case D3DFILL_POINT
: return PIPE_POLYGON_MODE_POINT
;
640 case D3DFILL_WIREFRAME
: return PIPE_POLYGON_MODE_LINE
;
641 case D3DFILL_SOLID
: return PIPE_POLYGON_MODE_FILL
;
642 case D3DFILL_SOLID_ZERO
:return PIPE_POLYGON_MODE_FILL
;
645 return PIPE_POLYGON_MODE_FILL
;
649 static inline unsigned
650 d3dblendop_to_pipe_blend(D3DBLENDOP op
)
653 case D3DBLENDOP_ADD
: return PIPE_BLEND_ADD
;
654 case D3DBLENDOP_SUBTRACT
: return PIPE_BLEND_SUBTRACT
;
655 case D3DBLENDOP_REVSUBTRACT
: return PIPE_BLEND_REVERSE_SUBTRACT
;
656 case D3DBLENDOP_MIN
: return PIPE_BLEND_MIN
;
657 case D3DBLENDOP_MAX
: return PIPE_BLEND_MAX
;
660 return PIPE_BLEND_ADD
;
664 /* NOTE: The COLOR factors for are equal to the ALPHA ones for alpha.
665 * Drivers may check RGB and ALPHA factors for equality so we should not
666 * simply substitute the ALPHA variants.
668 static inline unsigned
669 d3dblend_alpha_to_pipe_blendfactor(D3DBLEND b
)
672 case D3DBLEND_ZERO
: return PIPE_BLENDFACTOR_ZERO
;
673 case D3DBLEND_ONE
: return PIPE_BLENDFACTOR_ONE
;
674 case D3DBLEND_SRCCOLOR
: return PIPE_BLENDFACTOR_SRC_COLOR
/*ALPHA*/;
675 case D3DBLEND_INVSRCCOLOR
: return PIPE_BLENDFACTOR_INV_SRC_COLOR
/*ALPHA*/;
676 case D3DBLEND_SRCALPHA
: return PIPE_BLENDFACTOR_SRC_ALPHA
;
677 case D3DBLEND_INVSRCALPHA
: return PIPE_BLENDFACTOR_INV_SRC_ALPHA
;
678 case D3DBLEND_DESTALPHA
: return PIPE_BLENDFACTOR_DST_ALPHA
;
679 case D3DBLEND_INVDESTALPHA
: return PIPE_BLENDFACTOR_INV_DST_ALPHA
;
680 case D3DBLEND_DESTCOLOR
: return PIPE_BLENDFACTOR_DST_COLOR
/*ALPHA*/;
681 case D3DBLEND_INVDESTCOLOR
: return PIPE_BLENDFACTOR_INV_DST_COLOR
/*ALPHA*/;
682 case D3DBLEND_SRCALPHASAT
: return PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE
;
683 case D3DBLEND_BOTHSRCALPHA
: return PIPE_BLENDFACTOR_SRC_ALPHA
;
684 case D3DBLEND_BOTHINVSRCALPHA
: return PIPE_BLENDFACTOR_INV_SRC_ALPHA
;
685 case D3DBLEND_BLENDFACTOR
: return PIPE_BLENDFACTOR_CONST_COLOR
/*ALPHA*/;
686 case D3DBLEND_INVBLENDFACTOR
: return PIPE_BLENDFACTOR_INV_CONST_COLOR
/*ALPHA*/;
687 case D3DBLEND_SRCCOLOR2
: return PIPE_BLENDFACTOR_ONE
; /* XXX */
688 case D3DBLEND_INVSRCCOLOR2
: return PIPE_BLENDFACTOR_ZERO
; /* XXX */
690 DBG_FLAG(DBG_UNKNOWN
, "Unhandled blend factor %d\n", b
);
691 return PIPE_BLENDFACTOR_ZERO
;
695 static inline unsigned
696 d3dblend_color_to_pipe_blendfactor(D3DBLEND b
)
699 case D3DBLEND_ZERO
: return PIPE_BLENDFACTOR_ZERO
;
700 case D3DBLEND_ONE
: return PIPE_BLENDFACTOR_ONE
;
701 case D3DBLEND_SRCCOLOR
: return PIPE_BLENDFACTOR_SRC_COLOR
;
702 case D3DBLEND_INVSRCCOLOR
: return PIPE_BLENDFACTOR_INV_SRC_COLOR
;
703 case D3DBLEND_SRCALPHA
: return PIPE_BLENDFACTOR_SRC_ALPHA
;
704 case D3DBLEND_INVSRCALPHA
: return PIPE_BLENDFACTOR_INV_SRC_ALPHA
;
705 case D3DBLEND_DESTALPHA
: return PIPE_BLENDFACTOR_DST_ALPHA
;
706 case D3DBLEND_INVDESTALPHA
: return PIPE_BLENDFACTOR_INV_DST_ALPHA
;
707 case D3DBLEND_DESTCOLOR
: return PIPE_BLENDFACTOR_DST_COLOR
;
708 case D3DBLEND_INVDESTCOLOR
: return PIPE_BLENDFACTOR_INV_DST_COLOR
;
709 case D3DBLEND_SRCALPHASAT
: return PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE
;
710 case D3DBLEND_BOTHSRCALPHA
: return PIPE_BLENDFACTOR_SRC_ALPHA
;
711 case D3DBLEND_BOTHINVSRCALPHA
: return PIPE_BLENDFACTOR_INV_SRC_ALPHA
;
712 case D3DBLEND_BLENDFACTOR
: return PIPE_BLENDFACTOR_CONST_COLOR
;
713 case D3DBLEND_INVBLENDFACTOR
: return PIPE_BLENDFACTOR_INV_CONST_COLOR
;
714 case D3DBLEND_SRCCOLOR2
: return PIPE_BLENDFACTOR_SRC1_COLOR
;
715 case D3DBLEND_INVSRCCOLOR2
: return PIPE_BLENDFACTOR_INV_SRC1_COLOR
;
717 DBG_FLAG(DBG_UNKNOWN
, "Unhandled blend factor %d\n", b
);
718 return PIPE_BLENDFACTOR_ZERO
;
722 static inline unsigned
723 d3dtextureaddress_to_pipe_tex_wrap(D3DTEXTUREADDRESS addr
)
726 case D3DTADDRESS_WRAP
: return PIPE_TEX_WRAP_REPEAT
;
727 case D3DTADDRESS_MIRROR
: return PIPE_TEX_WRAP_MIRROR_REPEAT
;
728 case D3DTADDRESS_CLAMP
: return PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
729 case D3DTADDRESS_BORDER
: return PIPE_TEX_WRAP_CLAMP_TO_BORDER
;
730 case D3DTADDRESS_MIRRORONCE
: return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE
;
733 return PIPE_TEX_WRAP_CLAMP_TO_EDGE
;
737 static inline unsigned
738 d3dtexturefiltertype_to_pipe_tex_filter(D3DTEXTUREFILTERTYPE filter
)
741 case D3DTEXF_POINT
: return PIPE_TEX_FILTER_NEAREST
;
742 case D3DTEXF_LINEAR
: return PIPE_TEX_FILTER_LINEAR
;
743 case D3DTEXF_ANISOTROPIC
: return PIPE_TEX_FILTER_LINEAR
;
746 case D3DTEXF_PYRAMIDALQUAD
:
747 case D3DTEXF_GAUSSIANQUAD
:
748 case D3DTEXF_CONVOLUTIONMONO
:
751 return PIPE_TEX_FILTER_NEAREST
;
755 static inline unsigned
756 d3dtexturefiltertype_to_pipe_tex_mipfilter(D3DTEXTUREFILTERTYPE filter
)
759 case D3DTEXF_NONE
: return PIPE_TEX_MIPFILTER_NONE
;
760 case D3DTEXF_POINT
: return PIPE_TEX_FILTER_NEAREST
;
761 case D3DTEXF_LINEAR
: return PIPE_TEX_FILTER_LINEAR
;
762 case D3DTEXF_ANISOTROPIC
: return PIPE_TEX_FILTER_LINEAR
;
764 case D3DTEXF_PYRAMIDALQUAD
:
765 case D3DTEXF_GAUSSIANQUAD
:
766 case D3DTEXF_CONVOLUTIONMONO
:
769 return PIPE_TEX_MIPFILTER_NONE
;
773 static inline unsigned nine_format_get_stride(enum pipe_format format
,
776 unsigned stride
= util_format_get_stride(format
, width
);
778 return align(stride
, 4);
781 static inline unsigned nine_format_get_level_alloc_size(enum pipe_format format
,
788 w
= u_minify(width
, level
);
789 h
= u_minify(height
, level
);
790 if (is_ATI1_ATI2(format
)) {
791 /* For "unknown" formats like ATIx use width * height bytes */
793 } else if (format
== PIPE_FORMAT_NONE
) { /* D3DFMT_NULL */
796 size
= nine_format_get_stride(format
, w
) *
797 util_format_get_nblocksy(format
, h
);
803 static inline unsigned nine_format_get_size_and_offsets(enum pipe_format format
,
809 unsigned l
, w
, h
, size
= 0;
811 for (l
= 0; l
<= last_level
; ++l
) {
812 w
= u_minify(width
, l
);
813 h
= u_minify(height
, l
);
815 if (is_ATI1_ATI2(format
)) {
816 /* For "unknown" formats like ATIx use width * height bytes */
819 size
+= nine_format_get_stride(format
, w
) *
820 util_format_get_nblocksy(format
, h
);
827 #endif /* _NINE_PIPE_H_ */