• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
3  *
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:
10  *
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
13  * Software.
14  *
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. */
22 
23 #ifndef _NINE_PIPE_H_
24 #define _NINE_PIPE_H_
25 
26 #include "d3d9.h"
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/u_format.h"
33 #include "nine_helpers.h"
34 
35 struct cso_context;
36 
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];
39 
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 *);
44 
45 #define is_ATI1_ATI2(format) (format == PIPE_FORMAT_RGTC1_UNORM || format == PIPE_FORMAT_RGTC2_UNORM)
46 
47 static inline void
rect_to_pipe_box(struct pipe_box * dst,const RECT * src)48 rect_to_pipe_box(struct pipe_box *dst, const RECT *src)
49 {
50     dst->x = src->left;
51     dst->y = src->top;
52     dst->z = 0;
53     dst->width = src->right - src->left;
54     dst->height = src->bottom - src->top;
55     dst->depth = 1;
56 }
57 
58 static inline void
pipe_box_to_rect(RECT * dst,const struct pipe_box * src)59 pipe_box_to_rect(RECT *dst, const struct pipe_box *src)
60 {
61     dst->left = src->x;
62     dst->right = src->x + src->width;
63     dst->top = src->y;
64     dst->bottom = src->y + src->height;
65 }
66 
67 static inline void
rect_minify_inclusive(RECT * rect)68 rect_minify_inclusive(RECT *rect)
69 {
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);
74 }
75 
76 /* We suppose:
77  * 0 <= rect->left < rect->right
78  * 0 <= rect->top < rect->bottom
79  */
80 static inline void
fit_rect_format_inclusive(enum pipe_format format,RECT * rect,int width,int height)81 fit_rect_format_inclusive(enum pipe_format format, RECT *rect, int width, int height)
82 {
83     const unsigned w = util_format_get_blockwidth(format);
84     const unsigned h = util_format_get_blockheight(format);
85 
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 ?
90             rect->right :
91             rect->right - (rect->right % w) + w;
92         rect->bottom = (rect->bottom % h) == 0 ?
93             rect->bottom :
94             rect->bottom - (rect->bottom % h) + h;
95     }
96 
97     rect->right = MIN2(rect->right, width);
98     rect->bottom = MIN2(rect->bottom, height);
99 }
100 
101 static inline boolean
rect_to_pipe_box_clamp(struct pipe_box * dst,const RECT * src)102 rect_to_pipe_box_clamp(struct pipe_box *dst, const RECT *src)
103 {
104     rect_to_pipe_box(dst, src);
105 
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);
110         return TRUE;
111     }
112     return FALSE;
113 }
114 
115 static inline boolean
rect_to_pipe_box_flip(struct pipe_box * dst,const RECT * src)116 rect_to_pipe_box_flip(struct pipe_box *dst, const RECT *src)
117 {
118     rect_to_pipe_box(dst, src);
119 
120     if (dst->width >= 0 && dst->height >= 0)
121         return FALSE;
122     if (dst->width < 0) dst->width = -dst->width;
123     if (dst->height < 0) dst->height = -dst->height;
124     return TRUE;
125 }
126 
127 static inline void
rect_to_pipe_box_xy_only(struct pipe_box * dst,const RECT * src)128 rect_to_pipe_box_xy_only(struct pipe_box *dst, const RECT *src)
129 {
130     user_warn(src->left > src->right || src->top > src->bottom);
131 
132     dst->x = src->left;
133     dst->y = src->top;
134     dst->width = src->right - src->left;
135     dst->height = src->bottom - src->top;
136 }
137 
138 static inline boolean
rect_to_pipe_box_xy_only_clamp(struct pipe_box * dst,const RECT * src)139 rect_to_pipe_box_xy_only_clamp(struct pipe_box *dst, const RECT *src)
140 {
141     rect_to_pipe_box_xy_only(dst, src);
142 
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);
147         return TRUE;
148     }
149     return FALSE;
150 }
151 
152 static inline void
rect_to_g3d_u_rect(struct u_rect * dst,const RECT * src)153 rect_to_g3d_u_rect(struct u_rect *dst, const RECT *src)
154 {
155     user_warn(src->left > src->right || src->top > src->bottom);
156 
157     dst->x0 = src->left;
158     dst->x1 = src->right;
159     dst->y0 = src->top;
160     dst->y1 = src->bottom;
161 }
162 
163 static inline void
d3dbox_to_pipe_box(struct pipe_box * dst,const D3DBOX * src)164 d3dbox_to_pipe_box(struct pipe_box *dst, const D3DBOX *src)
165 {
166     user_warn(src->Left > src->Right);
167     user_warn(src->Top > src->Bottom);
168     user_warn(src->Front > src->Back);
169 
170     dst->x = src->Left;
171     dst->y = src->Top;
172     dst->z = src->Front;
173     dst->width = src->Right - src->Left;
174     dst->height = src->Bottom - src->Top;
175     dst->depth = src->Back - src->Front;
176 }
177 
178 static inline D3DFORMAT
pipe_to_d3d9_format(enum pipe_format format)179 pipe_to_d3d9_format(enum pipe_format format)
180 {
181     return nine_pipe_to_d3d9_format_map[format];
182 }
183 
184 /* ATI1 and ATI2 are not officially compressed in d3d9 */
185 static inline boolean
compressed_format(D3DFORMAT fmt)186 compressed_format( D3DFORMAT fmt )
187 {
188     switch (fmt) {
189     case D3DFMT_DXT1:
190     case D3DFMT_DXT2:
191     case D3DFMT_DXT3:
192     case D3DFMT_DXT4:
193     case D3DFMT_DXT5:
194         return TRUE;
195     default:
196         break;
197     }
198     return FALSE;
199 }
200 
201 static inline boolean
depth_stencil_format(D3DFORMAT fmt)202 depth_stencil_format( D3DFORMAT fmt )
203 {
204     static D3DFORMAT allowed[] = {
205         D3DFMT_D16_LOCKABLE,
206         D3DFMT_D32,
207         D3DFMT_D15S1,
208         D3DFMT_D24S8,
209         D3DFMT_D24X8,
210         D3DFMT_D24X4S4,
211         D3DFMT_D16,
212         D3DFMT_D32F_LOCKABLE,
213         D3DFMT_D24FS8,
214         D3DFMT_D32_LOCKABLE,
215         D3DFMT_DF16,
216         D3DFMT_DF24,
217         D3DFMT_INTZ
218     };
219     unsigned i;
220 
221     for (i = 0; i < sizeof(allowed)/sizeof(D3DFORMAT); i++) {
222         if (fmt == allowed[i]) { return TRUE; }
223     }
224     return FALSE;
225 }
226 
227 static inline unsigned
d3d9_get_pipe_depth_format_bindings(D3DFORMAT format)228 d3d9_get_pipe_depth_format_bindings(D3DFORMAT format)
229 {
230     switch (format) {
231     case D3DFMT_D32:
232     case D3DFMT_D15S1:
233     case D3DFMT_D24S8:
234     case D3DFMT_D24X8:
235     case D3DFMT_D24X4S4:
236     case D3DFMT_D16:
237     case D3DFMT_D24FS8:
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;
243     case D3DFMT_DF16:
244     case D3DFMT_DF24:
245     case D3DFMT_INTZ:
246         return PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_SAMPLER_VIEW;
247     default: unreachable("Unexpected format");
248     }
249 }
250 
251 static inline enum pipe_format
d3d9_to_pipe_format_internal(D3DFORMAT format)252 d3d9_to_pipe_format_internal(D3DFORMAT format)
253 {
254     if (format <= D3DFMT_A2B10G10R10_XR_BIAS)
255         return nine_d3d9_to_pipe_format_map[format];
256     switch (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 */
274     case D3DFMT_Y216:
275     case D3DFMT_NV11:
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;
281     default:
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;
286     }
287 }
288 
289 #define format_check_internal(pipe_format) \
290     screen->is_format_supported(screen, pipe_format, target, \
291                                 sample_count, bindings)
292 
293 static inline enum pipe_format
d3d9_to_pipe_format_checked(struct pipe_screen * screen,D3DFORMAT format,enum pipe_texture_target target,unsigned sample_count,unsigned bindings,boolean srgb,boolean bypass_check)294 d3d9_to_pipe_format_checked(struct pipe_screen *screen,
295                             D3DFORMAT format,
296                             enum pipe_texture_target target,
297                             unsigned sample_count,
298                             unsigned bindings,
299                             boolean srgb,
300                             boolean bypass_check)
301 {
302     enum pipe_format result;
303 
304     result = d3d9_to_pipe_format_internal(format);
305     if (result == PIPE_FORMAT_NONE)
306         return PIPE_FORMAT_NONE;
307 
308     if (srgb)
309         result = util_format_srgb(result);
310 
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
314      * fallback. */
315     if (bypass_check || format_check_internal(result))
316         return result;
317 
318     /* fallback to another format for formats
319      * that match several pipe_format */
320     switch(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.*/
325         case D3DFMT_INTZ:
326         case D3DFMT_D24S8:
327             if (format_check_internal(PIPE_FORMAT_Z24_UNORM_S8_UINT))
328                 return PIPE_FORMAT_Z24_UNORM_S8_UINT;
329             break;
330         case D3DFMT_D24X8:
331             if (format_check_internal(PIPE_FORMAT_Z24X8_UNORM))
332                 return PIPE_FORMAT_Z24X8_UNORM;
333             break;
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;
343         default:
344             break;
345     }
346     return PIPE_FORMAT_NONE;
347 }
348 
349 /* The quality levels are vendor dependent, so we set our own.
350  * Every quality level has its own sample count and sample
351  * position matrix.
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
354  * in D3D9.
355  * In case of NONMASKABLE multisample map every quality-level
356  * to a MASKABLE MultiSampleType:
357  *  0: no MSAA
358  *  1: 2x MSAA
359  *  2: 4x MSAA
360  *  ...
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.
365  */
366 static inline HRESULT
d3dmultisample_type_check(struct pipe_screen * screen,D3DFORMAT format,D3DMULTISAMPLE_TYPE * multisample,DWORD multisamplequality,DWORD * levels)367 d3dmultisample_type_check(struct pipe_screen *screen,
368                           D3DFORMAT format,
369                           D3DMULTISAMPLE_TYPE *multisample,
370                           DWORD multisamplequality,
371                           DWORD *levels)
372 {
373     unsigned bind, i;
374 
375     assert(multisample);
376 
377     if (levels)
378         *levels = 1;
379 
380     if (*multisample == D3DMULTISAMPLE_NONMASKABLE) {
381         if (depth_stencil_format(format))
382             bind = d3d9_get_pipe_depth_format_bindings(format);
383         else /* render-target */
384             bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
385 
386         *multisample = 0;
387         for (i = D3DMULTISAMPLE_2_SAMPLES; i < D3DMULTISAMPLE_16_SAMPLES &&
388             multisamplequality; ++i) {
389             if (d3d9_to_pipe_format_checked(screen, format, PIPE_TEXTURE_2D,
390                     i, bind, FALSE, FALSE) != PIPE_FORMAT_NONE) {
391                 multisamplequality--;
392                 if (levels)
393                     (*levels)++;
394                 *multisample = i;
395             }
396         }
397     }
398     /* Make sure to get an exact match */
399     if (multisamplequality)
400         return D3DERR_INVALIDCALL;
401     return D3D_OK;
402 }
403 
404 static inline const char *
d3dformat_to_string(D3DFORMAT fmt)405 d3dformat_to_string(D3DFORMAT fmt)
406 {
407     switch (fmt) {
408     case D3DFMT_UNKNOWN: return "D3DFMT_UNKNOWN";
409     case D3DFMT_R8G8B8: return "D3DFMT_R8G8B8";
410     case D3DFMT_A8R8G8B8: return "D3DFMT_A8R8G8B8";
411     case D3DFMT_X8R8G8B8: return "D3DFMT_X8R8G8B8";
412     case D3DFMT_R5G6B5: return "D3DFMT_R5G6B5";
413     case D3DFMT_X1R5G5B5: return "D3DFMT_X1R5G5B5";
414     case D3DFMT_A1R5G5B5: return "D3DFMT_A1R5G5B5";
415     case D3DFMT_A4R4G4B4: return "D3DFMT_A4R4G4B4";
416     case D3DFMT_R3G3B2: return "D3DFMT_R3G3B2";
417     case D3DFMT_A8: return "D3DFMT_A8";
418     case D3DFMT_A8R3G3B2: return "D3DFMT_A8R3G3B2";
419     case D3DFMT_X4R4G4B4: return "D3DFMT_X4R4G4B4";
420     case D3DFMT_A2B10G10R10: return "D3DFMT_A2B10G10R10";
421     case D3DFMT_A8B8G8R8: return "D3DFMT_A8B8G8R8";
422     case D3DFMT_X8B8G8R8: return "D3DFMT_X8B8G8R8";
423     case D3DFMT_G16R16: return "D3DFMT_G16R16";
424     case D3DFMT_A2R10G10B10: return "D3DFMT_A2R10G10B10";
425     case D3DFMT_A16B16G16R16: return "D3DFMT_A16B16G16R16";
426     case D3DFMT_A8P8: return "D3DFMT_A8P8";
427     case D3DFMT_P8: return "D3DFMT_P8";
428     case D3DFMT_L8: return "D3DFMT_L8";
429     case D3DFMT_A8L8: return "D3DFMT_A8L8";
430     case D3DFMT_A4L4: return "D3DFMT_A4L4";
431     case D3DFMT_V8U8: return "D3DFMT_V8U8";
432     case D3DFMT_L6V5U5: return "D3DFMT_L6V5U5";
433     case D3DFMT_X8L8V8U8: return "D3DFMT_X8L8V8U8";
434     case D3DFMT_Q8W8V8U8: return "D3DFMT_Q8W8V8U8";
435     case D3DFMT_V16U16: return "D3DFMT_V16U16";
436     case D3DFMT_A2W10V10U10: return "D3DFMT_A2W10V10U10";
437     case D3DFMT_UYVY: return "D3DFMT_UYVY";
438     case D3DFMT_R8G8_B8G8: return "D3DFMT_R8G8_B8G8";
439     case D3DFMT_YUY2: return "D3DFMT_YUY2";
440     case D3DFMT_G8R8_G8B8: return "D3DFMT_G8R8_G8B8";
441     case D3DFMT_DXT1: return "D3DFMT_DXT1";
442     case D3DFMT_DXT2: return "D3DFMT_DXT2";
443     case D3DFMT_DXT3: return "D3DFMT_DXT3";
444     case D3DFMT_DXT4: return "D3DFMT_DXT4";
445     case D3DFMT_DXT5: return "D3DFMT_DXT5";
446     case D3DFMT_ATI1: return "D3DFMT_ATI1";
447     case D3DFMT_ATI2: return "D3DFMT_ATI2";
448     case D3DFMT_D16_LOCKABLE: return "D3DFMT_D16_LOCKABLE";
449     case D3DFMT_D32: return "D3DFMT_D32";
450     case D3DFMT_D15S1: return "D3DFMT_D15S1";
451     case D3DFMT_D24S8: return "D3DFMT_D24S8";
452     case D3DFMT_D24X8: return "D3DFMT_D24X8";
453     case D3DFMT_D24X4S4: return "D3DFMT_D24X4S4";
454     case D3DFMT_D16: return "D3DFMT_D16";
455     case D3DFMT_D32F_LOCKABLE: return "D3DFMT_D32F_LOCKABLE";
456     case D3DFMT_D24FS8: return "D3DFMT_D24FS8";
457     case D3DFMT_D32_LOCKABLE: return "D3DFMT_D32_LOCKABLE";
458     case D3DFMT_S8_LOCKABLE: return "D3DFMT_S8_LOCKABLE";
459     case D3DFMT_L16: return "D3DFMT_L16";
460     case D3DFMT_VERTEXDATA: return "D3DFMT_VERTEXDATA";
461     case D3DFMT_INDEX16: return "D3DFMT_INDEX16";
462     case D3DFMT_INDEX32: return "D3DFMT_INDEX32";
463     case D3DFMT_Q16W16V16U16: return "D3DFMT_Q16W16V16U16";
464     case D3DFMT_MULTI2_ARGB8: return "D3DFMT_MULTI2_ARGB8";
465     case D3DFMT_R16F: return "D3DFMT_R16F";
466     case D3DFMT_G16R16F: return "D3DFMT_G16R16F";
467     case D3DFMT_A16B16G16R16F: return "D3DFMT_A16B16G16R16F";
468     case D3DFMT_R32F: return "D3DFMT_R32F";
469     case D3DFMT_G32R32F: return "D3DFMT_G32R32F";
470     case D3DFMT_A32B32G32R32F: return "D3DFMT_A32B32G32R32F";
471     case D3DFMT_CxV8U8: return "D3DFMT_CxV8U8";
472     case D3DFMT_A1: return "D3DFMT_A1";
473     case D3DFMT_A2B10G10R10_XR_BIAS: return "D3DFMT_A2B10G10R10_XR_BIAS";
474     case D3DFMT_BINARYBUFFER: return "D3DFMT_BINARYBUFFER";
475     case D3DFMT_DF16: return "D3DFMT_DF16";
476     case D3DFMT_DF24: return "D3DFMT_DF24";
477     case D3DFMT_INTZ: return "D3DFMT_INTZ";
478     case D3DFMT_NVDB: return "D3DFMT_NVDB";
479     case D3DFMT_RESZ: return "D3DFMT_RESZ";
480     case D3DFMT_NULL: return "D3DFMT_NULL";
481     case D3DFMT_ATOC: return "D3DFMT_ATOC";
482     default:
483         break;
484     }
485     return "Unknown";
486 }
487 
488 static inline unsigned
nine_fvf_stride(DWORD fvf)489 nine_fvf_stride( DWORD fvf )
490 {
491     unsigned texcount, i, size = 0;
492 
493     switch (fvf & D3DFVF_POSITION_MASK) {
494     case D3DFVF_XYZ:    size += 3*4; break;
495     case D3DFVF_XYZRHW: size += 4*4; break;
496     case D3DFVF_XYZB1:  size += 4*4; break;
497     case D3DFVF_XYZB2:  size += 5*4; break;
498     case D3DFVF_XYZB3:  size += 6*4; break;
499     case D3DFVF_XYZB4:  size += 7*4; break;
500     case D3DFVF_XYZB5:  size += 8*4; break;
501     case D3DFVF_XYZW:   size += 4*4; break;
502     default:
503         user_warn("Position doesn't match any known combination.");
504         break;
505     }
506 
507     if (fvf & D3DFVF_NORMAL)   { size += 3*4; }
508     if (fvf & D3DFVF_PSIZE)    { size += 1*4; }
509     if (fvf & D3DFVF_DIFFUSE)  { size += 1*4; }
510     if (fvf & D3DFVF_SPECULAR) { size += 1*4; }
511 
512     texcount = (fvf >> D3DFVF_TEXCOUNT_SHIFT) & D3DFVF_TEXCOUNT_MASK;
513     if (user_error(texcount <= 8))
514         texcount = 8;
515 
516     for (i = 0; i < texcount; ++i) {
517         unsigned texformat = (fvf>>(16+i*2))&0x3;
518         /* texformats are defined having been shifted around so 1=3,2=0,3=1,4=2
519          * meaning we can just do this instead of the switch below */
520         size += (((texformat+1)&0x3)+1)*4;
521 
522         /*
523         switch (texformat) {
524         case D3DFVF_TEXTUREFORMAT1: size += 1*4;
525         case D3DFVF_TEXTUREFORMAT2: size += 2*4;
526         case D3DFVF_TEXTUREFORMAT3: size += 3*4;
527         case D3DFVF_TEXTUREFORMAT4: size += 4*4;
528         }
529         */
530     }
531 
532     return size;
533 }
534 
535 static inline void
d3dcolor_to_rgba(float * rgba,D3DCOLOR color)536 d3dcolor_to_rgba(float *rgba, D3DCOLOR color)
537 {
538     rgba[0] = (float)((color >> 16) & 0xFF) / 0xFF;
539     rgba[1] = (float)((color >>  8) & 0xFF) / 0xFF;
540     rgba[2] = (float)((color >>  0) & 0xFF) / 0xFF;
541     rgba[3] = (float)((color >> 24) & 0xFF) / 0xFF;
542 }
543 
544 static inline void
d3dcolor_to_pipe_color_union(union pipe_color_union * rgba,D3DCOLOR color)545 d3dcolor_to_pipe_color_union(union pipe_color_union *rgba, D3DCOLOR color)
546 {
547     d3dcolor_to_rgba(&rgba->f[0], color);
548 }
549 
550 static inline unsigned
d3dprimitivetype_to_pipe_prim(D3DPRIMITIVETYPE prim)551 d3dprimitivetype_to_pipe_prim(D3DPRIMITIVETYPE prim)
552 {
553     switch (prim) {
554     case D3DPT_POINTLIST:     return PIPE_PRIM_POINTS;
555     case D3DPT_LINELIST:      return PIPE_PRIM_LINES;
556     case D3DPT_LINESTRIP:     return PIPE_PRIM_LINE_STRIP;
557     case D3DPT_TRIANGLELIST:  return PIPE_PRIM_TRIANGLES;
558     case D3DPT_TRIANGLESTRIP: return PIPE_PRIM_TRIANGLE_STRIP;
559     case D3DPT_TRIANGLEFAN:   return PIPE_PRIM_TRIANGLE_FAN;
560     default:
561         assert(0);
562         return PIPE_PRIM_POINTS;
563     }
564 }
565 
566 static inline unsigned
prim_count_to_vertex_count(D3DPRIMITIVETYPE prim,UINT count)567 prim_count_to_vertex_count(D3DPRIMITIVETYPE prim, UINT count)
568 {
569     switch (prim) {
570     case D3DPT_POINTLIST:     return count;
571     case D3DPT_LINELIST:      return count * 2;
572     case D3DPT_LINESTRIP:     return count + 1;
573     case D3DPT_TRIANGLELIST:  return count * 3;
574     case D3DPT_TRIANGLESTRIP: return count + 2;
575     case D3DPT_TRIANGLEFAN:   return count + 2;
576     default:
577         assert(0);
578         return 0;
579     }
580 }
581 
582 static inline unsigned
d3dcmpfunc_to_pipe_func(D3DCMPFUNC func)583 d3dcmpfunc_to_pipe_func(D3DCMPFUNC func)
584 {
585     switch (func) {
586     case D3DCMP_NEVER:        return PIPE_FUNC_NEVER;
587     case D3DCMP_LESS:         return PIPE_FUNC_LESS;
588     case D3DCMP_EQUAL:        return PIPE_FUNC_EQUAL;
589     case D3DCMP_LESSEQUAL:    return PIPE_FUNC_LEQUAL;
590     case D3DCMP_GREATER:      return PIPE_FUNC_GREATER;
591     case D3DCMP_NOTEQUAL:     return PIPE_FUNC_NOTEQUAL;
592     case D3DCMP_GREATEREQUAL: return PIPE_FUNC_GEQUAL;
593     case D3DCMP_ALWAYS:       return PIPE_FUNC_ALWAYS;
594     case D3DCMP_NEVER_ZERO:   return PIPE_FUNC_NEVER; // Tested on windows + ATI HD5770
595     default:
596         assert(0);
597         return PIPE_FUNC_NEVER;
598     }
599 }
600 
601 static inline unsigned
d3dstencilop_to_pipe_stencil_op(D3DSTENCILOP op)602 d3dstencilop_to_pipe_stencil_op(D3DSTENCILOP op)
603 {
604     switch (op) {
605     case D3DSTENCILOP_KEEP:    return PIPE_STENCIL_OP_KEEP;
606     case D3DSTENCILOP_ZERO:    return PIPE_STENCIL_OP_ZERO;
607     case D3DSTENCILOP_REPLACE: return PIPE_STENCIL_OP_REPLACE;
608     case D3DSTENCILOP_INCRSAT: return PIPE_STENCIL_OP_INCR;
609     case D3DSTENCILOP_DECRSAT: return PIPE_STENCIL_OP_DECR;
610     case D3DSTENCILOP_INVERT:  return PIPE_STENCIL_OP_INVERT;
611     case D3DSTENCILOP_INCR:    return PIPE_STENCIL_OP_INCR_WRAP;
612     case D3DSTENCILOP_DECR:    return PIPE_STENCIL_OP_DECR_WRAP;
613     default:
614         return PIPE_STENCIL_OP_ZERO;
615     }
616 }
617 
618 static inline unsigned
d3dcull_to_pipe_face(D3DCULL cull)619 d3dcull_to_pipe_face(D3DCULL cull)
620 {
621     switch (cull) {
622     case D3DCULL_NONE: return PIPE_FACE_NONE;
623     case D3DCULL_CW:   return PIPE_FACE_FRONT;
624     case D3DCULL_CCW:  return PIPE_FACE_BACK;
625     default:
626         assert(0);
627         return PIPE_FACE_NONE;
628     }
629 }
630 
631 static inline unsigned
d3dfillmode_to_pipe_polygon_mode(D3DFILLMODE mode)632 d3dfillmode_to_pipe_polygon_mode(D3DFILLMODE mode)
633 {
634     switch (mode) {
635     case D3DFILL_POINT:     return PIPE_POLYGON_MODE_POINT;
636     case D3DFILL_WIREFRAME: return PIPE_POLYGON_MODE_LINE;
637     case D3DFILL_SOLID:     return PIPE_POLYGON_MODE_FILL;
638     case D3DFILL_SOLID_ZERO:return PIPE_POLYGON_MODE_FILL;
639     default:
640         assert(0);
641         return PIPE_POLYGON_MODE_FILL;
642     }
643 }
644 
645 static inline unsigned
d3dblendop_to_pipe_blend(D3DBLENDOP op)646 d3dblendop_to_pipe_blend(D3DBLENDOP op)
647 {
648     switch (op) {
649     case D3DBLENDOP_ADD:         return PIPE_BLEND_ADD;
650     case D3DBLENDOP_SUBTRACT:    return PIPE_BLEND_SUBTRACT;
651     case D3DBLENDOP_REVSUBTRACT: return PIPE_BLEND_REVERSE_SUBTRACT;
652     case D3DBLENDOP_MIN:         return PIPE_BLEND_MIN;
653     case D3DBLENDOP_MAX:         return PIPE_BLEND_MAX;
654     default:
655         assert(0);
656         return PIPE_BLEND_ADD;
657     }
658 }
659 
660 /* NOTE: The COLOR factors for are equal to the ALPHA ones for alpha.
661  * Drivers may check RGB and ALPHA factors for equality so we should not
662  * simply substitute the ALPHA variants.
663  */
664 static inline unsigned
d3dblend_alpha_to_pipe_blendfactor(D3DBLEND b)665 d3dblend_alpha_to_pipe_blendfactor(D3DBLEND b)
666 {
667     switch (b) {
668     case D3DBLEND_ZERO:            return PIPE_BLENDFACTOR_ZERO;
669     case D3DBLEND_ONE:             return PIPE_BLENDFACTOR_ONE;
670     case D3DBLEND_SRCCOLOR:        return PIPE_BLENDFACTOR_SRC_COLOR/*ALPHA*/;
671     case D3DBLEND_INVSRCCOLOR:     return PIPE_BLENDFACTOR_INV_SRC_COLOR/*ALPHA*/;
672     case D3DBLEND_SRCALPHA:        return PIPE_BLENDFACTOR_SRC_ALPHA;
673     case D3DBLEND_INVSRCALPHA:     return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
674     case D3DBLEND_DESTALPHA:       return PIPE_BLENDFACTOR_DST_ALPHA;
675     case D3DBLEND_INVDESTALPHA:    return PIPE_BLENDFACTOR_INV_DST_ALPHA;
676     case D3DBLEND_DESTCOLOR:       return PIPE_BLENDFACTOR_DST_COLOR/*ALPHA*/;
677     case D3DBLEND_INVDESTCOLOR:    return PIPE_BLENDFACTOR_INV_DST_COLOR/*ALPHA*/;
678     case D3DBLEND_SRCALPHASAT:     return PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE;
679     case D3DBLEND_BOTHSRCALPHA:    return PIPE_BLENDFACTOR_SRC_ALPHA;
680     case D3DBLEND_BOTHINVSRCALPHA: return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
681     case D3DBLEND_BLENDFACTOR:     return PIPE_BLENDFACTOR_CONST_COLOR/*ALPHA*/;
682     case D3DBLEND_INVBLENDFACTOR:  return PIPE_BLENDFACTOR_INV_CONST_COLOR/*ALPHA*/;
683     case D3DBLEND_SRCCOLOR2:       return PIPE_BLENDFACTOR_ONE; /* XXX */
684     case D3DBLEND_INVSRCCOLOR2:    return PIPE_BLENDFACTOR_ZERO; /* XXX */
685     default:
686        DBG_FLAG(DBG_UNKNOWN, "Unhandled blend factor %d\n", b);
687        return PIPE_BLENDFACTOR_ZERO;
688     }
689 }
690 
691 static inline unsigned
d3dblend_color_to_pipe_blendfactor(D3DBLEND b)692 d3dblend_color_to_pipe_blendfactor(D3DBLEND b)
693 {
694     switch (b) {
695     case D3DBLEND_ZERO:            return PIPE_BLENDFACTOR_ZERO;
696     case D3DBLEND_ONE:             return PIPE_BLENDFACTOR_ONE;
697     case D3DBLEND_SRCCOLOR:        return PIPE_BLENDFACTOR_SRC_COLOR;
698     case D3DBLEND_INVSRCCOLOR:     return PIPE_BLENDFACTOR_INV_SRC_COLOR;
699     case D3DBLEND_SRCALPHA:        return PIPE_BLENDFACTOR_SRC_ALPHA;
700     case D3DBLEND_INVSRCALPHA:     return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
701     case D3DBLEND_DESTALPHA:       return PIPE_BLENDFACTOR_DST_ALPHA;
702     case D3DBLEND_INVDESTALPHA:    return PIPE_BLENDFACTOR_INV_DST_ALPHA;
703     case D3DBLEND_DESTCOLOR:       return PIPE_BLENDFACTOR_DST_COLOR;
704     case D3DBLEND_INVDESTCOLOR:    return PIPE_BLENDFACTOR_INV_DST_COLOR;
705     case D3DBLEND_SRCALPHASAT:     return PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE;
706     case D3DBLEND_BOTHSRCALPHA:    return PIPE_BLENDFACTOR_SRC_ALPHA;
707     case D3DBLEND_BOTHINVSRCALPHA: return PIPE_BLENDFACTOR_INV_SRC_ALPHA;
708     case D3DBLEND_BLENDFACTOR:     return PIPE_BLENDFACTOR_CONST_COLOR;
709     case D3DBLEND_INVBLENDFACTOR:  return PIPE_BLENDFACTOR_INV_CONST_COLOR;
710     case D3DBLEND_SRCCOLOR2:       return PIPE_BLENDFACTOR_SRC1_COLOR;
711     case D3DBLEND_INVSRCCOLOR2:    return PIPE_BLENDFACTOR_INV_SRC1_COLOR;
712     default:
713        DBG_FLAG(DBG_UNKNOWN, "Unhandled blend factor %d\n", b);
714        return PIPE_BLENDFACTOR_ZERO;
715     }
716 }
717 
718 static inline unsigned
d3dtextureaddress_to_pipe_tex_wrap(D3DTEXTUREADDRESS addr)719 d3dtextureaddress_to_pipe_tex_wrap(D3DTEXTUREADDRESS addr)
720 {
721     switch (addr) {
722     case D3DTADDRESS_WRAP:       return PIPE_TEX_WRAP_REPEAT;
723     case D3DTADDRESS_MIRROR:     return PIPE_TEX_WRAP_MIRROR_REPEAT;
724     case D3DTADDRESS_CLAMP:      return PIPE_TEX_WRAP_CLAMP_TO_EDGE;
725     case D3DTADDRESS_BORDER:     return PIPE_TEX_WRAP_CLAMP_TO_BORDER;
726     case D3DTADDRESS_MIRRORONCE: return PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE;
727     default:
728         assert(0);
729         return PIPE_TEX_WRAP_CLAMP_TO_EDGE;
730     }
731 }
732 
733 static inline unsigned
d3dtexturefiltertype_to_pipe_tex_filter(D3DTEXTUREFILTERTYPE filter)734 d3dtexturefiltertype_to_pipe_tex_filter(D3DTEXTUREFILTERTYPE filter)
735 {
736     switch (filter) {
737     case D3DTEXF_POINT:       return PIPE_TEX_FILTER_NEAREST;
738     case D3DTEXF_LINEAR:      return PIPE_TEX_FILTER_LINEAR;
739     case D3DTEXF_ANISOTROPIC: return PIPE_TEX_FILTER_LINEAR;
740 
741     case D3DTEXF_NONE:
742     case D3DTEXF_PYRAMIDALQUAD:
743     case D3DTEXF_GAUSSIANQUAD:
744     case D3DTEXF_CONVOLUTIONMONO:
745     default:
746         assert(0);
747         return PIPE_TEX_FILTER_NEAREST;
748     }
749 }
750 
751 static inline unsigned
d3dtexturefiltertype_to_pipe_tex_mipfilter(D3DTEXTUREFILTERTYPE filter)752 d3dtexturefiltertype_to_pipe_tex_mipfilter(D3DTEXTUREFILTERTYPE filter)
753 {
754     switch (filter) {
755     case D3DTEXF_NONE:        return PIPE_TEX_MIPFILTER_NONE;
756     case D3DTEXF_POINT:       return PIPE_TEX_FILTER_NEAREST;
757     case D3DTEXF_LINEAR:      return PIPE_TEX_FILTER_LINEAR;
758     case D3DTEXF_ANISOTROPIC: return PIPE_TEX_FILTER_LINEAR;
759 
760     case D3DTEXF_PYRAMIDALQUAD:
761     case D3DTEXF_GAUSSIANQUAD:
762     case D3DTEXF_CONVOLUTIONMONO:
763     default:
764         assert(0);
765         return PIPE_TEX_MIPFILTER_NONE;
766     }
767 }
768 
nine_format_get_stride(enum pipe_format format,unsigned width)769 static inline unsigned nine_format_get_stride(enum pipe_format format,
770                                               unsigned width)
771 {
772     unsigned stride = util_format_get_stride(format, width);
773 
774     return align(stride, 4);
775 }
776 
nine_format_get_level_alloc_size(enum pipe_format format,unsigned width,unsigned height,unsigned level)777 static inline unsigned nine_format_get_level_alloc_size(enum pipe_format format,
778                                                         unsigned width,
779                                                         unsigned height,
780                                                         unsigned level)
781 {
782     unsigned w, h, size;
783 
784     w = u_minify(width, level);
785     h = u_minify(height, level);
786     if (is_ATI1_ATI2(format)) {
787         /* For "unknown" formats like ATIx use width * height bytes */
788         size = w * h;
789     } else if (format == PIPE_FORMAT_NONE) { /* D3DFMT_NULL */
790         size = w * h * 4;
791     } else {
792         size = nine_format_get_stride(format, w) *
793             util_format_get_nblocksy(format, h);
794     }
795 
796     return size;
797 }
798 
nine_format_get_size_and_offsets(enum pipe_format format,unsigned * offsets,unsigned width,unsigned height,unsigned last_level)799 static inline unsigned nine_format_get_size_and_offsets(enum pipe_format format,
800                                                         unsigned *offsets,
801                                                         unsigned width,
802                                                         unsigned height,
803                                                         unsigned last_level)
804 {
805     unsigned l, w, h, size = 0;
806 
807     for (l = 0; l <= last_level; ++l) {
808         w = u_minify(width, l);
809         h = u_minify(height, l);
810         offsets[l] = size;
811         if (is_ATI1_ATI2(format)) {
812             /* For "unknown" formats like ATIx use width * height bytes */
813             size += w * h;
814         } else {
815             size += nine_format_get_stride(format, w) *
816                 util_format_get_nblocksy(format, h);
817         }
818     }
819 
820     return size;
821 }
822 
823 #endif /* _NINE_PIPE_H_ */
824